Interface Cluster

This cluster allows a client to manage the power draw of a device. An example of such a client could be an Energy Management System (EMS) which controls an Energy Smart Appliance (ESA).

In most deployments the EMS will be the client, and the ESA will host the Energy Management Cluster server.

Figure 15. Example of the how an EMS is a client of multiple ESAs Energy Management clusters.

This cluster is intended to be generic in nature and could apply to any electrical load or generator (e.g. a Battery Electric Storage System - BESS, solar PV inverter, EVSE, HVAC, heat pump, hot water heater, white goods appliances etc).

It consists of the following areas which shall be supported by all devices implementing this cluster:

• Description of ESA and its capabilities & power limits (sometimes referred to as a nameplate)

• Current state of operation (including user opt-out, safety limitations / alarms) There are some optional capabilities that some ESAs may be able to offer:

• Ability to control the load or generation

• Forecast data, including when it can be flexible (i.e. modify the power or time period)

• The ability to have their power profile adjusted by an EMS, and to provide an updated Forecast back to the EMS.

This allows the EMS to manage multiple home loads and where ESAs can be flexible, continuously optimizing the home energy to minimize cost, reduce CO2 impact, maximize self-consumption of solar PV and provide Demand Side Response (DSR) Grid services.

It is likely that the ESA may also use the Pricing Cluster to obtain incentive signals such as 'grid carbon intensity', 'time of use' or 'type of use' tariffs to schedule its operation to run at the cheapest and greenest times.

Figure 16. Example of the how an HVAC may use multiple clusters

NOTE

Grid Services are market dependent and will use other protocols ([OpenADR] / [IEEE2030.5]) to communicate grid events to the EMS. These are outside the scope of Matter.

NOTE

Different markets may follow different approaches, but the UK [PAS1878] and [EUCodeOfConduct] give examples of how ESAs may be mandated to support these features in the future.

NOTE Support of Device Energy Management Cluster is provisional.

Per the Matter specification you cannot use DeviceEnergyManagementCluster without enabling certain feature combinations. You must use the with factory method to obtain a working cluster.

See

MatterSpecification.v13.Cluster § 9.2

interface Cluster {
    id: ClusterId;
    name: string;
    with: (<const SelectionT>(...selection: SelectionT) => Of<Of<{
        attributes: {
            absMaxPower: Attribute<number | bigint, any>;
            absMinPower: Attribute<number | bigint, any>;
            esaCanGenerate: FixedAttribute<boolean, any>;
            esaState: Attribute<DeviceEnergyManagement.EsaState, any>;
            esaType: FixedAttribute<DeviceEnergyManagement.EsaType, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    powerAdjustmentCapability: Attribute<null | (...)[], any>;
                };
                commands: {
                    cancelPowerAdjustRequest: Command<void, void, any>;
                    powerAdjustRequest: Command<TypeFromFields<{
                        cause: ...;
                        duration: ...;
                        power: ...;
                    }>, void, any>;
                };
                events: {
                    powerAdjustEnd: Event<TypeFromFields<{
                        cause: ...;
                        duration: ...;
                        energyUse: ...;
                    }>, any>;
                    powerAdjustStart: Event<void, any>;
                };
            };
            flags: {
                powerAdjustment: true;
            };
        }, {
            component: {
                attributes: {
                    forecast: Attribute<null | TypeFromFields<(...)>, any>;
                };
            };
            flags: {
                powerForecastReporting: true;
            };
        }, {
            component: {
                attributes: {
                    forecast: Attribute<null | TypeFromFields<(...)>, any>;
                };
            };
            flags: {
                stateForecastReporting: true;
            };
        }, {
            component: {
                attributes: {
                    optOutState: Attribute<DeviceEnergyManagement.OptOutState, any>;
                };
            };
            flags: {
                powerAdjustment: true;
            };
        }, {
            component: {
                attributes: {
                    optOutState: Attribute<DeviceEnergyManagement.OptOutState, any>;
                };
            };
            flags: {
                startTimeAdjustment: true;
            };
        }, {
            component: {
                attributes: {
                    optOutState: Attribute<DeviceEnergyManagement.OptOutState, any>;
                };
            };
            flags: {
                pausable: true;
            };
        }, {
            component: {
                attributes: {
                    optOutState: Attribute<DeviceEnergyManagement.OptOutState, any>;
                };
            };
            flags: {
                forecastAdjustment: true;
            };
        }, {
            component: {
                attributes: {
                    optOutState: Attribute<DeviceEnergyManagement.OptOutState, any>;
                };
            };
            flags: {
                constraintBasedAdjustment: true;
            };
        }, {
            component: {
                commands: {
                    pauseRequest: Command<TypeFromFields<{
                        cause: ...;
                        duration: ...;
                    }>, void, any>;
                    resumeRequest: Command<void, void, any>;
                };
                events: {
                    paused: Event<void, any>;
                    resumed: Event<TypeFromFields<{
                        cause: ...;
                    }>, any>;
                };
            };
            flags: {
                pausable: true;
            };
        }, {
            component: {
                commands: {
                    startTimeAdjustRequest: Command<TypeFromFields<{
                        cause: ...;
                        requestedStartTime: ...;
                    }>, void, any>;
                };
            };
            flags: {
                startTimeAdjustment: true;
            };
        }, {
            component: {
                commands: {
                    modifyForecastRequest: Command<TypeFromFields<{
                        cause: ...;
                        forecastId: ...;
                        slotAdjustments: ...;
                    }>, void, any>;
                };
            };
            flags: {
                forecastAdjustment: true;
            };
        }, {
            component: {
                commands: {
                    requestConstraintBasedForecast: Command<TypeFromFields<{
                        cause: ...;
                        constraints: ...;
                    }>, void, any>;
                };
            };
            flags: {
                constraintBasedAdjustment: true;
            };
        }, {
            component: {
                commands: {
                    cancelRequest: Command<void, void, any>;
                };
            };
            flags: {
                startTimeAdjustment: true;
            };
        }, {
            component: {
                commands: {
                    cancelRequest: Command<void, void, any>;
                };
            };
            flags: {
                forecastAdjustment: true;
            };
        }, {
            component: {
                commands: {
                    cancelRequest: Command<void, void, any>;
                };
            };
            flags: {
                constraintBasedAdjustment: true;
            };
        }, {
            component: false;
            flags: {
                feature: false;
                startTimeAdjustment: true;
                stateForecastReporting: false;
            };
        }, {
            component: false;
            flags: {
                feature: false;
                pausable: true;
                stateForecastReporting: false;
            };
        }, {
            component: false;
            flags: {
                feature: false;
                forecastAdjustment: true;
                stateForecastReporting: false;
            };
        }, {
            component: false;
            flags: {
                constraintBasedAdjustment: true;
                feature: false;
                stateForecastReporting: false;
            };
        }, {
            component: false;
            flags: {
                feature: false;
                powerForecastReporting: false;
                startTimeAdjustment: true;
            };
        }, {
            component: false;
            flags: {
                feature: false;
                pausable: true;
                powerForecastReporting: false;
            };
        }, {
            component: false;
            flags: {
                feature: false;
                forecastAdjustment: true;
                powerForecastReporting: false;
            };
        }, {
            component: false;
            flags: {
                constraintBasedAdjustment: true;
                feature: false;
                powerForecastReporting: false;
            };
        }, {
            component: false;
            flags: {
                constraintBasedAdjustment: false;
                forecastAdjustment: false;
                pausable: false;
                powerAdjustment: false;
                powerForecastReporting: false;
                startTimeAdjustment: false;
                stateForecastReporting: false;
            };
        }];
        features: {
            constraintBasedAdjustment: BitFlag;
            forecastAdjustment: BitFlag;
            pausable: BitFlag;
            powerAdjustment: BitFlag;
            powerForecastReporting: BitFlag;
            startTimeAdjustment: BitFlag;
            stateForecastReporting: BitFlag;
        };
        id: 152;
        name: "DeviceEnergyManagement";
        revision: 3;
    }>, SelectionT>);
}

Hierarchy (view full)

Properties

id name with

Properties

id

id: ClusterId

name

name: string

with

with: (<const SelectionT>(...selection: SelectionT) => Of<Of<{
    attributes: {
        absMaxPower: Attribute<number | bigint, any>;
        absMinPower: Attribute<number | bigint, any>;
        esaCanGenerate: FixedAttribute<boolean, any>;
        esaState: Attribute<DeviceEnergyManagement.EsaState, any>;
        esaType: FixedAttribute<DeviceEnergyManagement.EsaType, any>;
    };
    extensions: readonly [{
        component: {
            attributes: {
                powerAdjustmentCapability: Attribute<null | (...)[], any>;
            };
            commands: {
                cancelPowerAdjustRequest: Command<void, void, any>;
                powerAdjustRequest: Command<TypeFromFields<{
                    cause: ...;
                    duration: ...;
                    power: ...;
                }>, void, any>;
            };
            events: {
                powerAdjustEnd: Event<TypeFromFields<{
                    cause: ...;
                    duration: ...;
                    energyUse: ...;
                }>, any>;
                powerAdjustStart: Event<void, any>;
            };
        };
        flags: {
            powerAdjustment: true;
        };
    }, {
        component: {
            attributes: {
                forecast: Attribute<null | TypeFromFields<(...)>, any>;
            };
        };
        flags: {
            powerForecastReporting: true;
        };
    }, {
        component: {
            attributes: {
                forecast: Attribute<null | TypeFromFields<(...)>, any>;
            };
        };
        flags: {
            stateForecastReporting: true;
        };
    }, {
        component: {
            attributes: {
                optOutState: Attribute<DeviceEnergyManagement.OptOutState, any>;
            };
        };
        flags: {
            powerAdjustment: true;
        };
    }, {
        component: {
            attributes: {
                optOutState: Attribute<DeviceEnergyManagement.OptOutState, any>;
            };
        };
        flags: {
            startTimeAdjustment: true;
        };
    }, {
        component: {
            attributes: {
                optOutState: Attribute<DeviceEnergyManagement.OptOutState, any>;
            };
        };
        flags: {
            pausable: true;
        };
    }, {
        component: {
            attributes: {
                optOutState: Attribute<DeviceEnergyManagement.OptOutState, any>;
            };
        };
        flags: {
            forecastAdjustment: true;
        };
    }, {
        component: {
            attributes: {
                optOutState: Attribute<DeviceEnergyManagement.OptOutState, any>;
            };
        };
        flags: {
            constraintBasedAdjustment: true;
        };
    }, {
        component: {
            commands: {
                pauseRequest: Command<TypeFromFields<{
                    cause: ...;
                    duration: ...;
                }>, void, any>;
                resumeRequest: Command<void, void, any>;
            };
            events: {
                paused: Event<void, any>;
                resumed: Event<TypeFromFields<{
                    cause: ...;
                }>, any>;
            };
        };
        flags: {
            pausable: true;
        };
    }, {
        component: {
            commands: {
                startTimeAdjustRequest: Command<TypeFromFields<{
                    cause: ...;
                    requestedStartTime: ...;
                }>, void, any>;
            };
        };
        flags: {
            startTimeAdjustment: true;
        };
    }, {
        component: {
            commands: {
                modifyForecastRequest: Command<TypeFromFields<{
                    cause: ...;
                    forecastId: ...;
                    slotAdjustments: ...;
                }>, void, any>;
            };
        };
        flags: {
            forecastAdjustment: true;
        };
    }, {
        component: {
            commands: {
                requestConstraintBasedForecast: Command<TypeFromFields<{
                    cause: ...;
                    constraints: ...;
                }>, void, any>;
            };
        };
        flags: {
            constraintBasedAdjustment: true;
        };
    }, {
        component: {
            commands: {
                cancelRequest: Command<void, void, any>;
            };
        };
        flags: {
            startTimeAdjustment: true;
        };
    }, {
        component: {
            commands: {
                cancelRequest: Command<void, void, any>;
            };
        };
        flags: {
            forecastAdjustment: true;
        };
    }, {
        component: {
            commands: {
                cancelRequest: Command<void, void, any>;
            };
        };
        flags: {
            constraintBasedAdjustment: true;
        };
    }, {
        component: false;
        flags: {
            feature: false;
            startTimeAdjustment: true;
            stateForecastReporting: false;
        };
    }, {
        component: false;
        flags: {
            feature: false;
            pausable: true;
            stateForecastReporting: false;
        };
    }, {
        component: false;
        flags: {
            feature: false;
            forecastAdjustment: true;
            stateForecastReporting: false;
        };
    }, {
        component: false;
        flags: {
            constraintBasedAdjustment: true;
            feature: false;
            stateForecastReporting: false;
        };
    }, {
        component: false;
        flags: {
            feature: false;
            powerForecastReporting: false;
            startTimeAdjustment: true;
        };
    }, {
        component: false;
        flags: {
            feature: false;
            pausable: true;
            powerForecastReporting: false;
        };
    }, {
        component: false;
        flags: {
            feature: false;
            forecastAdjustment: true;
            powerForecastReporting: false;
        };
    }, {
        component: false;
        flags: {
            constraintBasedAdjustment: true;
            feature: false;
            powerForecastReporting: false;
        };
    }, {
        component: false;
        flags: {
            constraintBasedAdjustment: false;
            forecastAdjustment: false;
            pausable: false;
            powerAdjustment: false;
            powerForecastReporting: false;
            startTimeAdjustment: false;
            stateForecastReporting: false;
        };
    }];
    features: {
        constraintBasedAdjustment: BitFlag;
        forecastAdjustment: BitFlag;
        pausable: BitFlag;
        powerAdjustment: BitFlag;
        powerForecastReporting: BitFlag;
        startTimeAdjustment: BitFlag;
        stateForecastReporting: BitFlag;
    };
    id: 152;
    name: "DeviceEnergyManagement";
    revision: 3;
}>, SelectionT>)

Type declaration

    • <const SelectionT>(...selection): Of<Of<{
          attributes: {
              absMaxPower: Attribute<number | bigint, any>;
              absMinPower: Attribute<number | bigint, any>;
              esaCanGenerate: FixedAttribute<boolean, any>;
              esaState: Attribute<DeviceEnergyManagement.EsaState, any>;
              esaType: FixedAttribute<DeviceEnergyManagement.EsaType, any>;
          };
          extensions: readonly [{
              component: {
                  attributes: {
                      powerAdjustmentCapability: Attribute<null | (...)[], any>;
                  };
                  commands: {
                      cancelPowerAdjustRequest: Command<void, void, any>;
                      powerAdjustRequest: Command<TypeFromFields<{
                          cause: ...;
                          duration: ...;
                          power: ...;
                      }>, void, any>;
                  };
                  events: {
                      powerAdjustEnd: Event<TypeFromFields<{
                          cause: ...;
                          duration: ...;
                          energyUse: ...;
                      }>, any>;
                      powerAdjustStart: Event<void, any>;
                  };
              };
              flags: {
                  powerAdjustment: true;
              };
          }, {
              component: {
                  attributes: {
                      forecast: Attribute<null | TypeFromFields<(...)>, any>;
                  };
              };
              flags: {
                  powerForecastReporting: true;
              };
          }, {
              component: {
                  attributes: {
                      forecast: Attribute<null | TypeFromFields<(...)>, any>;
                  };
              };
              flags: {
                  stateForecastReporting: true;
              };
          }, {
              component: {
                  attributes: {
                      optOutState: Attribute<DeviceEnergyManagement.OptOutState, any>;
                  };
              };
              flags: {
                  powerAdjustment: true;
              };
          }, {
              component: {
                  attributes: {
                      optOutState: Attribute<DeviceEnergyManagement.OptOutState, any>;
                  };
              };
              flags: {
                  startTimeAdjustment: true;
              };
          }, {
              component: {
                  attributes: {
                      optOutState: Attribute<DeviceEnergyManagement.OptOutState, any>;
                  };
              };
              flags: {
                  pausable: true;
              };
          }, {
              component: {
                  attributes: {
                      optOutState: Attribute<DeviceEnergyManagement.OptOutState, any>;
                  };
              };
              flags: {
                  forecastAdjustment: true;
              };
          }, {
              component: {
                  attributes: {
                      optOutState: Attribute<DeviceEnergyManagement.OptOutState, any>;
                  };
              };
              flags: {
                  constraintBasedAdjustment: true;
              };
          }, {
              component: {
                  commands: {
                      pauseRequest: Command<TypeFromFields<{
                          cause: ...;
                          duration: ...;
                      }>, void, any>;
                      resumeRequest: Command<void, void, any>;
                  };
                  events: {
                      paused: Event<void, any>;
                      resumed: Event<TypeFromFields<{
                          cause: ...;
                      }>, any>;
                  };
              };
              flags: {
                  pausable: true;
              };
          }, {
              component: {
                  commands: {
                      startTimeAdjustRequest: Command<TypeFromFields<{
                          cause: ...;
                          requestedStartTime: ...;
                      }>, void, any>;
                  };
              };
              flags: {
                  startTimeAdjustment: true;
              };
          }, {
              component: {
                  commands: {
                      modifyForecastRequest: Command<TypeFromFields<{
                          cause: ...;
                          forecastId: ...;
                          slotAdjustments: ...;
                      }>, void, any>;
                  };
              };
              flags: {
                  forecastAdjustment: true;
              };
          }, {
              component: {
                  commands: {
                      requestConstraintBasedForecast: Command<TypeFromFields<{
                          cause: ...;
                          constraints: ...;
                      }>, void, any>;
                  };
              };
              flags: {
                  constraintBasedAdjustment: true;
              };
          }, {
              component: {
                  commands: {
                      cancelRequest: Command<void, void, any>;
                  };
              };
              flags: {
                  startTimeAdjustment: true;
              };
          }, {
              component: {
                  commands: {
                      cancelRequest: Command<void, void, any>;
                  };
              };
              flags: {
                  forecastAdjustment: true;
              };
          }, {
              component: {
                  commands: {
                      cancelRequest: Command<void, void, any>;
                  };
              };
              flags: {
                  constraintBasedAdjustment: true;
              };
          }, {
              component: false;
              flags: {
                  feature: false;
                  startTimeAdjustment: true;
                  stateForecastReporting: false;
              };
          }, {
              component: false;
              flags: {
                  feature: false;
                  pausable: true;
                  stateForecastReporting: false;
              };
          }, {
              component: false;
              flags: {
                  feature: false;
                  forecastAdjustment: true;
                  stateForecastReporting: false;
              };
          }, {
              component: false;
              flags: {
                  constraintBasedAdjustment: true;
                  feature: false;
                  stateForecastReporting: false;
              };
          }, {
              component: false;
              flags: {
                  feature: false;
                  powerForecastReporting: false;
                  startTimeAdjustment: true;
              };
          }, {
              component: false;
              flags: {
                  feature: false;
                  pausable: true;
                  powerForecastReporting: false;
              };
          }, {
              component: false;
              flags: {
                  feature: false;
                  forecastAdjustment: true;
                  powerForecastReporting: false;
              };
          }, {
              component: false;
              flags: {
                  constraintBasedAdjustment: true;
                  feature: false;
                  powerForecastReporting: false;
              };
          }, {
              component: false;
              flags: {
                  constraintBasedAdjustment: false;
                  forecastAdjustment: false;
                  pausable: false;
                  powerAdjustment: false;
                  powerForecastReporting: false;
                  startTimeAdjustment: false;
                  stateForecastReporting: false;
              };
          }];
          features: {
              constraintBasedAdjustment: BitFlag;
              forecastAdjustment: BitFlag;
              pausable: BitFlag;
              powerAdjustment: BitFlag;
              powerForecastReporting: BitFlag;
              startTimeAdjustment: BitFlag;
              stateForecastReporting: BitFlag;
          };
          id: 152;
          name: "DeviceEnergyManagement";
          revision: 3;
      }>, SelectionT>

    • Select features using ClusterComposer.compose.

      Type Parameters

      • const SelectionT extends FeatureSelection<Of<{
            attributes: {
                absMaxPower: Attribute<number | bigint, any>;
                absMinPower: Attribute<number | bigint, any>;
                esaCanGenerate: FixedAttribute<boolean, any>;
                esaState: Attribute<DeviceEnergyManagement.EsaState, any>;
                esaType: FixedAttribute<DeviceEnergyManagement.EsaType, any>;
            };
            extensions: readonly [{
                component: {
                    attributes: {
                        powerAdjustmentCapability: Attribute<null | (...)[], any>;
                    };
                    commands: {
                        cancelPowerAdjustRequest: Command<void, void, any>;
                        powerAdjustRequest: Command<TypeFromFields<{
                            cause: ...;
                            duration: ...;
                            power: ...;
                        }>, void, any>;
                    };
                    events: {
                        powerAdjustEnd: Event<TypeFromFields<{
                            cause: ...;
                            duration: ...;
                            energyUse: ...;
                        }>, any>;
                        powerAdjustStart: Event<void, any>;
                    };
                };
                flags: {
                    powerAdjustment: true;
                };
            }, {
                component: {
                    attributes: {
                        forecast: Attribute<null | TypeFromFields<(...)>, any>;
                    };
                };
                flags: {
                    powerForecastReporting: true;
                };
            }, {
                component: {
                    attributes: {
                        forecast: Attribute<null | TypeFromFields<(...)>, any>;
                    };
                };
                flags: {
                    stateForecastReporting: true;
                };
            }, {
                component: {
                    attributes: {
                        optOutState: Attribute<DeviceEnergyManagement.OptOutState, any>;
                    };
                };
                flags: {
                    powerAdjustment: true;
                };
            }, {
                component: {
                    attributes: {
                        optOutState: Attribute<DeviceEnergyManagement.OptOutState, any>;
                    };
                };
                flags: {
                    startTimeAdjustment: true;
                };
            }, {
                component: {
                    attributes: {
                        optOutState: Attribute<DeviceEnergyManagement.OptOutState, any>;
                    };
                };
                flags: {
                    pausable: true;
                };
            }, {
                component: {
                    attributes: {
                        optOutState: Attribute<DeviceEnergyManagement.OptOutState, any>;
                    };
                };
                flags: {
                    forecastAdjustment: true;
                };
            }, {
                component: {
                    attributes: {
                        optOutState: Attribute<DeviceEnergyManagement.OptOutState, any>;
                    };
                };
                flags: {
                    constraintBasedAdjustment: true;
                };
            }, {
                component: {
                    commands: {
                        pauseRequest: Command<TypeFromFields<{
                            cause: ...;
                            duration: ...;
                        }>, void, any>;
                        resumeRequest: Command<void, void, any>;
                    };
                    events: {
                        paused: Event<void, any>;
                        resumed: Event<TypeFromFields<{
                            cause: ...;
                        }>, any>;
                    };
                };
                flags: {
                    pausable: true;
                };
            }, {
                component: {
                    commands: {
                        startTimeAdjustRequest: Command<TypeFromFields<{
                            cause: ...;
                            requestedStartTime: ...;
                        }>, void, any>;
                    };
                };
                flags: {
                    startTimeAdjustment: true;
                };
            }, {
                component: {
                    commands: {
                        modifyForecastRequest: Command<TypeFromFields<{
                            cause: ...;
                            forecastId: ...;
                            slotAdjustments: ...;
                        }>, void, any>;
                    };
                };
                flags: {
                    forecastAdjustment: true;
                };
            }, {
                component: {
                    commands: {
                        requestConstraintBasedForecast: Command<TypeFromFields<{
                            cause: ...;
                            constraints: ...;
                        }>, void, any>;
                    };
                };
                flags: {
                    constraintBasedAdjustment: true;
                };
            }, {
                component: {
                    commands: {
                        cancelRequest: Command<void, void, any>;
                    };
                };
                flags: {
                    startTimeAdjustment: true;
                };
            }, {
                component: {
                    commands: {
                        cancelRequest: Command<void, void, any>;
                    };
                };
                flags: {
                    forecastAdjustment: true;
                };
            }, {
                component: {
                    commands: {
                        cancelRequest: Command<void, void, any>;
                    };
                };
                flags: {
                    constraintBasedAdjustment: true;
                };
            }, {
                component: false;
                flags: {
                    feature: false;
                    startTimeAdjustment: true;
                    stateForecastReporting: false;
                };
            }, {
                component: false;
                flags: {
                    feature: false;
                    pausable: true;
                    stateForecastReporting: false;
                };
            }, {
                component: false;
                flags: {
                    feature: false;
                    forecastAdjustment: true;
                    stateForecastReporting: false;
                };
            }, {
                component: false;
                flags: {
                    constraintBasedAdjustment: true;
                    feature: false;
                    stateForecastReporting: false;
                };
            }, {
                component: false;
                flags: {
                    feature: false;
                    powerForecastReporting: false;
                    startTimeAdjustment: true;
                };
            }, {
                component: false;
                flags: {
                    feature: false;
                    pausable: true;
                    powerForecastReporting: false;
                };
            }, {
                component: false;
                flags: {
                    feature: false;
                    forecastAdjustment: true;
                    powerForecastReporting: false;
                };
            }, {
                component: false;
                flags: {
                    constraintBasedAdjustment: true;
                    feature: false;
                    powerForecastReporting: false;
                };
            }, {
                component: false;
                flags: {
                    constraintBasedAdjustment: false;
                    forecastAdjustment: false;
                    pausable: false;
                    powerAdjustment: false;
                    powerForecastReporting: false;
                    startTimeAdjustment: false;
                    stateForecastReporting: false;
                };
            }];
            features: {
                constraintBasedAdjustment: BitFlag;
                forecastAdjustment: BitFlag;
                pausable: BitFlag;
                powerAdjustment: BitFlag;
                powerForecastReporting: BitFlag;
                startTimeAdjustment: BitFlag;
                stateForecastReporting: BitFlag;
            };
            id: 152;
            name: "DeviceEnergyManagement";
            revision: 3;
        }>>

      Parameters

      Returns Of<Of<{
          attributes: {
              absMaxPower: Attribute<number | bigint, any>;
              absMinPower: Attribute<number | bigint, any>;
              esaCanGenerate: FixedAttribute<boolean, any>;
              esaState: Attribute<DeviceEnergyManagement.EsaState, any>;
              esaType: FixedAttribute<DeviceEnergyManagement.EsaType, any>;
          };
          extensions: readonly [{
              component: {
                  attributes: {
                      powerAdjustmentCapability: Attribute<null | (...)[], any>;
                  };
                  commands: {
                      cancelPowerAdjustRequest: Command<void, void, any>;
                      powerAdjustRequest: Command<TypeFromFields<{
                          cause: ...;
                          duration: ...;
                          power: ...;
                      }>, void, any>;
                  };
                  events: {
                      powerAdjustEnd: Event<TypeFromFields<{
                          cause: ...;
                          duration: ...;
                          energyUse: ...;
                      }>, any>;
                      powerAdjustStart: Event<void, any>;
                  };
              };
              flags: {
                  powerAdjustment: true;
              };
          }, {
              component: {
                  attributes: {
                      forecast: Attribute<null | TypeFromFields<(...)>, any>;
                  };
              };
              flags: {
                  powerForecastReporting: true;
              };
          }, {
              component: {
                  attributes: {
                      forecast: Attribute<null | TypeFromFields<(...)>, any>;
                  };
              };
              flags: {
                  stateForecastReporting: true;
              };
          }, {
              component: {
                  attributes: {
                      optOutState: Attribute<DeviceEnergyManagement.OptOutState, any>;
                  };
              };
              flags: {
                  powerAdjustment: true;
              };
          }, {
              component: {
                  attributes: {
                      optOutState: Attribute<DeviceEnergyManagement.OptOutState, any>;
                  };
              };
              flags: {
                  startTimeAdjustment: true;
              };
          }, {
              component: {
                  attributes: {
                      optOutState: Attribute<DeviceEnergyManagement.OptOutState, any>;
                  };
              };
              flags: {
                  pausable: true;
              };
          }, {
              component: {
                  attributes: {
                      optOutState: Attribute<DeviceEnergyManagement.OptOutState, any>;
                  };
              };
              flags: {
                  forecastAdjustment: true;
              };
          }, {
              component: {
                  attributes: {
                      optOutState: Attribute<DeviceEnergyManagement.OptOutState, any>;
                  };
              };
              flags: {
                  constraintBasedAdjustment: true;
              };
          }, {
              component: {
                  commands: {
                      pauseRequest: Command<TypeFromFields<{
                          cause: ...;
                          duration: ...;
                      }>, void, any>;
                      resumeRequest: Command<void, void, any>;
                  };
                  events: {
                      paused: Event<void, any>;
                      resumed: Event<TypeFromFields<{
                          cause: ...;
                      }>, any>;
                  };
              };
              flags: {
                  pausable: true;
              };
          }, {
              component: {
                  commands: {
                      startTimeAdjustRequest: Command<TypeFromFields<{
                          cause: ...;
                          requestedStartTime: ...;
                      }>, void, any>;
                  };
              };
              flags: {
                  startTimeAdjustment: true;
              };
          }, {
              component: {
                  commands: {
                      modifyForecastRequest: Command<TypeFromFields<{
                          cause: ...;
                          forecastId: ...;
                          slotAdjustments: ...;
                      }>, void, any>;
                  };
              };
              flags: {
                  forecastAdjustment: true;
              };
          }, {
              component: {
                  commands: {
                      requestConstraintBasedForecast: Command<TypeFromFields<{
                          cause: ...;
                          constraints: ...;
                      }>, void, any>;
                  };
              };
              flags: {
                  constraintBasedAdjustment: true;
              };
          }, {
              component: {
                  commands: {
                      cancelRequest: Command<void, void, any>;
                  };
              };
              flags: {
                  startTimeAdjustment: true;
              };
          }, {
              component: {
                  commands: {
                      cancelRequest: Command<void, void, any>;
                  };
              };
              flags: {
                  forecastAdjustment: true;
              };
          }, {
              component: {
                  commands: {
                      cancelRequest: Command<void, void, any>;
                  };
              };
              flags: {
                  constraintBasedAdjustment: true;
              };
          }, {
              component: false;
              flags: {
                  feature: false;
                  startTimeAdjustment: true;
                  stateForecastReporting: false;
              };
          }, {
              component: false;
              flags: {
                  feature: false;
                  pausable: true;
                  stateForecastReporting: false;
              };
          }, {
              component: false;
              flags: {
                  feature: false;
                  forecastAdjustment: true;
                  stateForecastReporting: false;
              };
          }, {
              component: false;
              flags: {
                  constraintBasedAdjustment: true;
                  feature: false;
                  stateForecastReporting: false;
              };
          }, {
              component: false;
              flags: {
                  feature: false;
                  powerForecastReporting: false;
                  startTimeAdjustment: true;
              };
          }, {
              component: false;
              flags: {
                  feature: false;
                  pausable: true;
                  powerForecastReporting: false;
              };
          }, {
              component: false;
              flags: {
                  feature: false;
                  forecastAdjustment: true;
                  powerForecastReporting: false;
              };
          }, {
              component: false;
              flags: {
                  constraintBasedAdjustment: true;
                  feature: false;
                  powerForecastReporting: false;
              };
          }, {
              component: false;
              flags: {
                  constraintBasedAdjustment: false;
                  forecastAdjustment: false;
                  pausable: false;
                  powerAdjustment: false;
                  powerForecastReporting: false;
                  startTimeAdjustment: false;
                  stateForecastReporting: false;
              };
          }];
          features: {
              constraintBasedAdjustment: BitFlag;
              forecastAdjustment: BitFlag;
              pausable: BitFlag;
              powerAdjustment: BitFlag;
              powerForecastReporting: BitFlag;
              startTimeAdjustment: BitFlag;
              stateForecastReporting: BitFlag;
          };
          id: 152;
          name: "DeviceEnergyManagement";
          revision: 3;
      }>, SelectionT>

Settings

Member Visibility

On This Page

Properties