This cluster supports all DeviceEnergyManagement features. It may support illegal feature combinations.

If you use this cluster you must manually specify which features are active and ensure the set of active features is legal per the Matter specification.

interface Complete {
    attributes: Merge<{
        absMaxPower: Attribute<number | bigint, any>;
        absMinPower: Attribute<number | bigint, any>;
        esaCanGenerate: FixedAttribute<boolean, any>;
        esaState: Attribute<DeviceEnergyManagement.EsaState, any>;
        esaType: FixedAttribute<DeviceEnergyManagement.EsaType, any>;
        forecast: Attribute<null | TypeFromFields<{
            activeSlotNumber: FieldType<null | number>;
            earliestStartTime: OptionalFieldType<null | number>;
            endTime: FieldType<number>;
            forecastId: FieldType<number>;
            forecastUpdateReason: FieldType<DeviceEnergyManagement.ForecastUpdateReason>;
            isPauseable: FieldType<boolean>;
            latestEndTime: OptionalFieldType<number>;
            slots: FieldType<TypeFromFields<{
                costs: ...;
                defaultDuration: ...;
                elapsedSlotTime: ...;
                manufacturerEsaState: ...;
                maxDuration: ...;
                maxDurationAdjustment: ...;
                maxPauseDuration: ...;
                maxPower: ...;
                maxPowerAdjustment: ...;
                minDuration: ...;
                minDurationAdjustment: ...;
                minPauseDuration: ...;
                minPower: ...;
                minPowerAdjustment: ...;
                nominalEnergy: ...;
                nominalPower: ...;
                remainingSlotTime: ...;
                slotIsPauseable: ...;
            }>[]>;
            startTime: FieldType<number>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                powerForecastReporting: boolean;
            }, {
                stateForecastReporting: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        optOutState: Attribute<DeviceEnergyManagement.OptOutState, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                powerAdjustment: boolean;
            }, {
                startTimeAdjustment: boolean;
            }, {
                pausable: boolean;
            }, {
                forecastAdjustment: boolean;
            }, {
                constraintBasedAdjustment: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        powerAdjustmentCapability: Attribute<null | TypeFromFields<{
            maxDuration: FieldType<number>;
            maxPower: FieldType<number | bigint>;
            minDuration: FieldType<number>;
            minPower: FieldType<number | bigint>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                powerAdjustment: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    }, GlobalAttributes<{
        constraintBasedAdjustment: BitFlag;
        forecastAdjustment: BitFlag;
        pausable: BitFlag;
        powerAdjustment: BitFlag;
        powerForecastReporting: BitFlag;
        startTimeAdjustment: BitFlag;
        stateForecastReporting: BitFlag;
    }>>;
    base: undefined;
    commands: {
        cancelPowerAdjustRequest: Command<void, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                powerAdjustment: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        cancelRequest: Command<void, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                startTimeAdjustment: boolean;
            }, {
                forecastAdjustment: boolean;
            }, {
                constraintBasedAdjustment: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        modifyForecastRequest: Command<TypeFromFields<{
            cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
            forecastId: FieldType<number>;
            slotAdjustments: FieldType<TypeFromFields<{
                duration: FieldType<number>;
                nominalPower: FieldType<(...) | (...)>;
                slotIndex: FieldType<number>;
            }>[]>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                forecastAdjustment: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        pauseRequest: Command<TypeFromFields<{
            cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
            duration: FieldType<number>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                pausable: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        powerAdjustRequest: Command<TypeFromFields<{
            cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
            duration: FieldType<number>;
            power: FieldType<number | bigint>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                powerAdjustment: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        requestConstraintBasedForecast: Command<TypeFromFields<{
            cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
            constraints: FieldType<TypeFromFields<{
                duration: FieldType<number>;
                loadControl: OptionalFieldType<number>;
                maximumEnergy: OptionalFieldType<(...) | (...)>;
                nominalPower: OptionalFieldType<(...) | (...)>;
                startTime: FieldType<number>;
            }>[]>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                constraintBasedAdjustment: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        resumeRequest: Command<void, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                pausable: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        startTimeAdjustRequest: Command<TypeFromFields<{
            cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
            requestedStartTime: FieldType<number>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                startTimeAdjustment: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    events: {
        paused: Event<void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                pausable: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        powerAdjustEnd: Event<TypeFromFields<{
            cause: FieldType<DeviceEnergyManagement.Cause>;
            duration: FieldType<number>;
            energyUse: FieldType<number | bigint>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                powerAdjustment: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        powerAdjustStart: Event<void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                powerAdjustment: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        resumed: Event<TypeFromFields<{
            cause: FieldType<DeviceEnergyManagement.Cause>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                pausable: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    extensions: undefined;
    features: {
        constraintBasedAdjustment: BitFlag;
        forecastAdjustment: BitFlag;
        pausable: BitFlag;
        powerAdjustment: BitFlag;
        powerForecastReporting: BitFlag;
        startTimeAdjustment: BitFlag;
        stateForecastReporting: BitFlag;
    };
    id: Branded<152, "ClusterId">;
    name: "DeviceEnergyManagement";
    revision: 3;
    supportedFeatures: {};
    unknown: false;
    alter<const AlterationsT>(alterations: AlterationsT): WithAlterations<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>;
            forecast: Attribute<null | TypeFromFields<{
                activeSlotNumber: FieldType<(...) | (...)>;
                earliestStartTime: OptionalFieldType<(...) | (...)>;
                endTime: FieldType<number>;
                forecastId: FieldType<number>;
                forecastUpdateReason: FieldType<DeviceEnergyManagement.ForecastUpdateReason>;
                isPauseable: FieldType<boolean>;
                latestEndTime: OptionalFieldType<number>;
                slots: FieldType<(...)[]>;
                startTime: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerForecastReporting: boolean;
                }, {
                    stateForecastReporting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            optOutState: Attribute<DeviceEnergyManagement.OptOutState, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAdjustment: boolean;
                }, {
                    startTimeAdjustment: boolean;
                }, {
                    pausable: boolean;
                }, {
                    forecastAdjustment: boolean;
                }, {
                    constraintBasedAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            powerAdjustmentCapability: Attribute<null | TypeFromFields<{
                maxDuration: FieldType<(...)>;
                maxPower: FieldType<(...)>;
                minDuration: FieldType<(...)>;
                minPower: FieldType<(...)>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            cancelPowerAdjustRequest: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            cancelRequest: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    startTimeAdjustment: boolean;
                }, {
                    forecastAdjustment: boolean;
                }, {
                    constraintBasedAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            modifyForecastRequest: Command<TypeFromFields<{
                cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
                forecastId: FieldType<number>;
                slotAdjustments: FieldType<TypeFromFields<(...)>[]>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    forecastAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            pauseRequest: Command<TypeFromFields<{
                cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
                duration: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pausable: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            powerAdjustRequest: Command<TypeFromFields<{
                cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
                duration: FieldType<number>;
                power: FieldType<number | bigint>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            requestConstraintBasedForecast: Command<TypeFromFields<{
                cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
                constraints: FieldType<TypeFromFields<(...)>[]>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constraintBasedAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            resumeRequest: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pausable: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            startTimeAdjustRequest: Command<TypeFromFields<{
                cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
                requestedStartTime: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    startTimeAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        events: {
            paused: Event<void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pausable: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            powerAdjustEnd: Event<TypeFromFields<{
                cause: FieldType<DeviceEnergyManagement.Cause>;
                duration: FieldType<number>;
                energyUse: FieldType<number | bigint>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            powerAdjustStart: Event<void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            resumed: Event<TypeFromFields<{
                cause: FieldType<DeviceEnergyManagement.Cause>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pausable: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            constraintBasedAdjustment: BitFlag;
            forecastAdjustment: BitFlag;
            pausable: BitFlag;
            powerAdjustment: BitFlag;
            powerForecastReporting: BitFlag;
            startTimeAdjustment: BitFlag;
            stateForecastReporting: BitFlag;
        };
        id: 152;
        name: "DeviceEnergyManagement";
        revision: 3;
    }>, AlterationsT>;
    enable<const FlagsT>(flags: FlagsT): WithFlags<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>;
            forecast: Attribute<null | TypeFromFields<{
                activeSlotNumber: FieldType<(...) | (...)>;
                earliestStartTime: OptionalFieldType<(...) | (...)>;
                endTime: FieldType<number>;
                forecastId: FieldType<number>;
                forecastUpdateReason: FieldType<DeviceEnergyManagement.ForecastUpdateReason>;
                isPauseable: FieldType<boolean>;
                latestEndTime: OptionalFieldType<number>;
                slots: FieldType<(...)[]>;
                startTime: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerForecastReporting: boolean;
                }, {
                    stateForecastReporting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            optOutState: Attribute<DeviceEnergyManagement.OptOutState, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAdjustment: boolean;
                }, {
                    startTimeAdjustment: boolean;
                }, {
                    pausable: boolean;
                }, {
                    forecastAdjustment: boolean;
                }, {
                    constraintBasedAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            powerAdjustmentCapability: Attribute<null | TypeFromFields<{
                maxDuration: FieldType<(...)>;
                maxPower: FieldType<(...)>;
                minDuration: FieldType<(...)>;
                minPower: FieldType<(...)>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            cancelPowerAdjustRequest: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            cancelRequest: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    startTimeAdjustment: boolean;
                }, {
                    forecastAdjustment: boolean;
                }, {
                    constraintBasedAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            modifyForecastRequest: Command<TypeFromFields<{
                cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
                forecastId: FieldType<number>;
                slotAdjustments: FieldType<TypeFromFields<(...)>[]>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    forecastAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            pauseRequest: Command<TypeFromFields<{
                cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
                duration: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pausable: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            powerAdjustRequest: Command<TypeFromFields<{
                cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
                duration: FieldType<number>;
                power: FieldType<number | bigint>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            requestConstraintBasedForecast: Command<TypeFromFields<{
                cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
                constraints: FieldType<TypeFromFields<(...)>[]>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constraintBasedAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            resumeRequest: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pausable: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            startTimeAdjustRequest: Command<TypeFromFields<{
                cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
                requestedStartTime: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    startTimeAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        events: {
            paused: Event<void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pausable: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            powerAdjustEnd: Event<TypeFromFields<{
                cause: FieldType<DeviceEnergyManagement.Cause>;
                duration: FieldType<number>;
                energyUse: FieldType<number | bigint>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            powerAdjustStart: Event<void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            resumed: Event<TypeFromFields<{
                cause: FieldType<DeviceEnergyManagement.Cause>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pausable: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            constraintBasedAdjustment: BitFlag;
            forecastAdjustment: BitFlag;
            pausable: BitFlag;
            powerAdjustment: BitFlag;
            powerForecastReporting: BitFlag;
            startTimeAdjustment: BitFlag;
            stateForecastReporting: BitFlag;
        };
        id: 152;
        name: "DeviceEnergyManagement";
        revision: 3;
    }>, FlagsT>;
    set<const ValuesT>(values: ValuesT): WithValues<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>;
            forecast: Attribute<null | TypeFromFields<{
                activeSlotNumber: FieldType<(...) | (...)>;
                earliestStartTime: OptionalFieldType<(...) | (...)>;
                endTime: FieldType<number>;
                forecastId: FieldType<number>;
                forecastUpdateReason: FieldType<DeviceEnergyManagement.ForecastUpdateReason>;
                isPauseable: FieldType<boolean>;
                latestEndTime: OptionalFieldType<number>;
                slots: FieldType<(...)[]>;
                startTime: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerForecastReporting: boolean;
                }, {
                    stateForecastReporting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            optOutState: Attribute<DeviceEnergyManagement.OptOutState, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAdjustment: boolean;
                }, {
                    startTimeAdjustment: boolean;
                }, {
                    pausable: boolean;
                }, {
                    forecastAdjustment: boolean;
                }, {
                    constraintBasedAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            powerAdjustmentCapability: Attribute<null | TypeFromFields<{
                maxDuration: FieldType<(...)>;
                maxPower: FieldType<(...)>;
                minDuration: FieldType<(...)>;
                minPower: FieldType<(...)>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            cancelPowerAdjustRequest: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            cancelRequest: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    startTimeAdjustment: boolean;
                }, {
                    forecastAdjustment: boolean;
                }, {
                    constraintBasedAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            modifyForecastRequest: Command<TypeFromFields<{
                cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
                forecastId: FieldType<number>;
                slotAdjustments: FieldType<TypeFromFields<(...)>[]>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    forecastAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            pauseRequest: Command<TypeFromFields<{
                cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
                duration: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pausable: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            powerAdjustRequest: Command<TypeFromFields<{
                cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
                duration: FieldType<number>;
                power: FieldType<number | bigint>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            requestConstraintBasedForecast: Command<TypeFromFields<{
                cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
                constraints: FieldType<TypeFromFields<(...)>[]>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constraintBasedAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            resumeRequest: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pausable: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            startTimeAdjustRequest: Command<TypeFromFields<{
                cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
                requestedStartTime: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    startTimeAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        events: {
            paused: Event<void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pausable: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            powerAdjustEnd: Event<TypeFromFields<{
                cause: FieldType<DeviceEnergyManagement.Cause>;
                duration: FieldType<number>;
                energyUse: FieldType<number | bigint>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            powerAdjustStart: Event<void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            resumed: Event<TypeFromFields<{
                cause: FieldType<DeviceEnergyManagement.Cause>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pausable: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            constraintBasedAdjustment: BitFlag;
            forecastAdjustment: BitFlag;
            pausable: BitFlag;
            powerAdjustment: BitFlag;
            powerForecastReporting: BitFlag;
            startTimeAdjustment: BitFlag;
            stateForecastReporting: BitFlag;
        };
        id: 152;
        name: "DeviceEnergyManagement";
        revision: 3;
    }>, ValuesT>;
    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>;
            forecast: Attribute<null | TypeFromFields<{
                activeSlotNumber: FieldType<(...) | (...)>;
                earliestStartTime: OptionalFieldType<(...) | (...)>;
                endTime: FieldType<number>;
                forecastId: FieldType<number>;
                forecastUpdateReason: FieldType<DeviceEnergyManagement.ForecastUpdateReason>;
                isPauseable: FieldType<boolean>;
                latestEndTime: OptionalFieldType<number>;
                slots: FieldType<(...)[]>;
                startTime: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerForecastReporting: boolean;
                }, {
                    stateForecastReporting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            optOutState: Attribute<DeviceEnergyManagement.OptOutState, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAdjustment: boolean;
                }, {
                    startTimeAdjustment: boolean;
                }, {
                    pausable: boolean;
                }, {
                    forecastAdjustment: boolean;
                }, {
                    constraintBasedAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            powerAdjustmentCapability: Attribute<null | TypeFromFields<{
                maxDuration: FieldType<(...)>;
                maxPower: FieldType<(...)>;
                minDuration: FieldType<(...)>;
                minPower: FieldType<(...)>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            cancelPowerAdjustRequest: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            cancelRequest: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    startTimeAdjustment: boolean;
                }, {
                    forecastAdjustment: boolean;
                }, {
                    constraintBasedAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            modifyForecastRequest: Command<TypeFromFields<{
                cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
                forecastId: FieldType<number>;
                slotAdjustments: FieldType<TypeFromFields<(...)>[]>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    forecastAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            pauseRequest: Command<TypeFromFields<{
                cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
                duration: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pausable: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            powerAdjustRequest: Command<TypeFromFields<{
                cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
                duration: FieldType<number>;
                power: FieldType<number | bigint>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            requestConstraintBasedForecast: Command<TypeFromFields<{
                cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
                constraints: FieldType<TypeFromFields<(...)>[]>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constraintBasedAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            resumeRequest: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pausable: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            startTimeAdjustRequest: Command<TypeFromFields<{
                cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
                requestedStartTime: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    startTimeAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        events: {
            paused: Event<void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pausable: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            powerAdjustEnd: Event<TypeFromFields<{
                cause: FieldType<DeviceEnergyManagement.Cause>;
                duration: FieldType<number>;
                energyUse: FieldType<number | bigint>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            powerAdjustStart: Event<void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            resumed: Event<TypeFromFields<{
                cause: FieldType<DeviceEnergyManagement.Cause>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pausable: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        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

attributes: Merge<{
    absMaxPower: Attribute<number | bigint, any>;
    absMinPower: Attribute<number | bigint, any>;
    esaCanGenerate: FixedAttribute<boolean, any>;
    esaState: Attribute<DeviceEnergyManagement.EsaState, any>;
    esaType: FixedAttribute<DeviceEnergyManagement.EsaType, any>;
    forecast: Attribute<null | TypeFromFields<{
        activeSlotNumber: FieldType<null | number>;
        earliestStartTime: OptionalFieldType<null | number>;
        endTime: FieldType<number>;
        forecastId: FieldType<number>;
        forecastUpdateReason: FieldType<DeviceEnergyManagement.ForecastUpdateReason>;
        isPauseable: FieldType<boolean>;
        latestEndTime: OptionalFieldType<number>;
        slots: FieldType<TypeFromFields<{
            costs: ...;
            defaultDuration: ...;
            elapsedSlotTime: ...;
            manufacturerEsaState: ...;
            maxDuration: ...;
            maxDurationAdjustment: ...;
            maxPauseDuration: ...;
            maxPower: ...;
            maxPowerAdjustment: ...;
            minDuration: ...;
            minDurationAdjustment: ...;
            minPauseDuration: ...;
            minPower: ...;
            minPowerAdjustment: ...;
            nominalEnergy: ...;
            nominalPower: ...;
            remainingSlotTime: ...;
            slotIsPauseable: ...;
        }>[]>;
        startTime: FieldType<number>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            powerForecastReporting: boolean;
        }, {
            stateForecastReporting: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    optOutState: Attribute<DeviceEnergyManagement.OptOutState, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            powerAdjustment: boolean;
        }, {
            startTimeAdjustment: boolean;
        }, {
            pausable: boolean;
        }, {
            forecastAdjustment: boolean;
        }, {
            constraintBasedAdjustment: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    powerAdjustmentCapability: Attribute<null | TypeFromFields<{
        maxDuration: FieldType<number>;
        maxPower: FieldType<number | bigint>;
        minDuration: FieldType<number>;
        minPower: FieldType<number | bigint>;
    }>[], any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            powerAdjustment: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
}, GlobalAttributes<{
    constraintBasedAdjustment: BitFlag;
    forecastAdjustment: BitFlag;
    pausable: BitFlag;
    powerAdjustment: BitFlag;
    powerForecastReporting: BitFlag;
    startTimeAdjustment: BitFlag;
    stateForecastReporting: BitFlag;
}>>

Type declaration

  • ReadonlyabsMaxPower: Attribute<number | bigint, any>

    Indicates the maximum electrical power that the ESA can consume when switched on.

    The value of the AbsMaxPower attribute shall be limited

    AbsMaxPower >= AbsMinPower

    Note that for Generator ESAs that can discharge a battery to loads in the home (such as a battery storage inverter), the AbsMaxPower will be a positive number representing the maximum power at which the ESA can discharge its internal battery.

    For example, a battery storage inverter that can charge its battery at a maximum power of 2000W and can discharge the battery at a maximum power of 3000W, would have a AbsMinPower: -2000, AbsMaxPower: 3000W.

    MatterSpecification.v13.Cluster § 9.2.8.5

  • ReadonlyabsMinPower: Attribute<number | bigint, any>

    Indicates the minimum electrical power that the ESA can consume when switched on. This does not include when in power save or standby modes.

    Note that for Generator ESAs that can charge an internal battery (such as a battery storage inverter), the AbsMinPower will be a negative number representing the maximum power that the ESA can charge its internal battery.

    MatterSpecification.v13.Cluster § 9.2.8.4

  • ReadonlyesaCanGenerate: FixedAttribute<boolean, any>

    Indicates whether the ESA is classed as a generator or load. This allows an EMS to understand whether the power values reported by the ESA need to have their sign inverted when dealing with forecasts and adjustments.

    For example, a solar PV inverter (being a generator) may produce positive values to indicate generation, however an EMS when predicting the total home load would need to subtract these positive values from the loads to compute a net import at the grid meter.

    For example, a home battery storage system (BESS) which needs to charge the battery and then discharge to the home loads, would be classed as a generator. These types of devices shall have this field set to true. When generating its forecast or advertising its PowerAdjustmentCapability, the power values shall be positive to indicate discharging to the loads in the home, and negative to indicate when it is charging its battery.

    GRID meter = Σ LoadPowers - Σ GeneratorPowers

    Example:

    MatterSpecification.v13.Cluster § 9.2.8.2

  • ReadonlyesaState: Attribute<DeviceEnergyManagement.EsaState, any>

    Indicates the current state of the ESA.

    If the ESA is in the Offline or Fault state it cannot be controlled by an EMS, and may not be able to report its Forecast information. An EMS may subscribe to the ESAState to get notified about changes in operational state.

    The ESA may have a local user interface to allow a service technician to put the ESA into Offline mode, for example to avoid the EMS accidentally starting or stopping the appliance when it is being serviced or tested.

    MatterSpecification.v13.Cluster § 9.2.8.3

  • ReadonlyesaType: FixedAttribute<DeviceEnergyManagement.EsaType, any>

    Indicates the type of ESA.

    This attribute enables an EMS to understand some of the basic properties about how the energy may be consumed, generated, and stored by the ESA.

    For example, the heat energy converted by a heat pump will naturally be lost through the building to the outdoor environment relatively quickly, compared to storing heat in a well-insulated hot water tank. Similarly, battery storage and EVs can store electrical energy for much longer durations.

    This attribute can also help the EMS display information to a user and to make basic assumptions about typical best use of energy. For example, an EVSE may not always have an EV plugged in, so knowing the type of ESA that is being controlled can allow advanced energy management strategies.

    MatterSpecification.v13.Cluster § 9.2.8.1

  • Readonlyforecast: Attribute<null | TypeFromFields<{
        activeSlotNumber: FieldType<null | number>;
        earliestStartTime: OptionalFieldType<null | number>;
        endTime: FieldType<number>;
        forecastId: FieldType<number>;
        forecastUpdateReason: FieldType<DeviceEnergyManagement.ForecastUpdateReason>;
        isPauseable: FieldType<boolean>;
        latestEndTime: OptionalFieldType<number>;
        slots: FieldType<TypeFromFields<{
            costs: ...;
            defaultDuration: ...;
            elapsedSlotTime: ...;
            manufacturerEsaState: ...;
            maxDuration: ...;
            maxDurationAdjustment: ...;
            maxPauseDuration: ...;
            maxPower: ...;
            maxPowerAdjustment: ...;
            minDuration: ...;
            minDurationAdjustment: ...;
            minPauseDuration: ...;
            minPower: ...;
            minPowerAdjustment: ...;
            nominalEnergy: ...;
            nominalPower: ...;
            remainingSlotTime: ...;
            slotIsPauseable: ...;
        }>[]>;
        startTime: FieldType<number>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            powerForecastReporting: boolean;
        }, {
            stateForecastReporting: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlyoptOutState: Attribute<DeviceEnergyManagement.OptOutState, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            powerAdjustment: boolean;
        }, {
            startTimeAdjustment: boolean;
        }, {
            pausable: boolean;
        }, {
            forecastAdjustment: boolean;
        }, {
            constraintBasedAdjustment: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlypowerAdjustmentCapability: Attribute<null | TypeFromFields<{
        maxDuration: FieldType<number>;
        maxPower: FieldType<number | bigint>;
        minDuration: FieldType<number>;
        minPower: FieldType<number | bigint>;
    }>[], any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            powerAdjustment: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
base: undefined
commands: {
    cancelPowerAdjustRequest: Command<void, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            powerAdjustment: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    cancelRequest: Command<void, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            startTimeAdjustment: boolean;
        }, {
            forecastAdjustment: boolean;
        }, {
            constraintBasedAdjustment: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    modifyForecastRequest: Command<TypeFromFields<{
        cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
        forecastId: FieldType<number>;
        slotAdjustments: FieldType<TypeFromFields<{
            duration: FieldType<number>;
            nominalPower: FieldType<(...) | (...)>;
            slotIndex: FieldType<number>;
        }>[]>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            forecastAdjustment: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    pauseRequest: Command<TypeFromFields<{
        cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
        duration: FieldType<number>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            pausable: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    powerAdjustRequest: Command<TypeFromFields<{
        cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
        duration: FieldType<number>;
        power: FieldType<number | bigint>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            powerAdjustment: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    requestConstraintBasedForecast: Command<TypeFromFields<{
        cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
        constraints: FieldType<TypeFromFields<{
            duration: FieldType<number>;
            loadControl: OptionalFieldType<number>;
            maximumEnergy: OptionalFieldType<(...) | (...)>;
            nominalPower: OptionalFieldType<(...) | (...)>;
            startTime: FieldType<number>;
        }>[]>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            constraintBasedAdjustment: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    resumeRequest: Command<void, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            pausable: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    startTimeAdjustRequest: Command<TypeFromFields<{
        cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
        requestedStartTime: FieldType<number>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            startTimeAdjustment: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
}
events: {
    paused: Event<void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            pausable: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    powerAdjustEnd: Event<TypeFromFields<{
        cause: FieldType<DeviceEnergyManagement.Cause>;
        duration: FieldType<number>;
        energyUse: FieldType<number | bigint>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            powerAdjustment: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    powerAdjustStart: Event<void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            powerAdjustment: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    resumed: Event<TypeFromFields<{
        cause: FieldType<DeviceEnergyManagement.Cause>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            pausable: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
}
extensions: undefined
features: {
    constraintBasedAdjustment: BitFlag;
    forecastAdjustment: BitFlag;
    pausable: BitFlag;
    powerAdjustment: BitFlag;
    powerForecastReporting: BitFlag;
    startTimeAdjustment: BitFlag;
    stateForecastReporting: BitFlag;
}

Type declaration

  • ReadonlyconstraintBasedAdjustment: BitFlag

    ConstraintBasedAdjustment

    ESAs which support the Constraint-Based Adjustment feature allow an EMS to inform the ESA of periods during which power usage should be modified (for example when the EMS has been made aware that the grid supplier has requested reduced energy usage due to overall peak grid demand) and may cause the ESA to modify the intended power profile has previously suggested it would use.

    EVSE example: An EVSE scheduling system may have determined that the vehicle would be charged starting at a moderate rate at 1am, so that it has enough charge by the time it is needed later that morning.

    However, the DSR service provider has informed the EMS that due to high forecast winds it is now forecast that there will be very cheap energy available from wind generation between 2am and 3am.

    The EMS first requests the Forecast data from each of its registered ESAs. It determines that the

    EVSE has a power profile suggesting it plans to start charging the vehicle at 1am.

    The EMS can then try to reduce the cost of charging the EV by informing the EVSE of the desire to increase the charging between scheduled times.

    It does this by sending a RequestConstraintBasedForecast to the EVSE and asks it to run at a higher NominalPower consumption during the constraint period, which may require it to decrease its charge rate outside the constraint period to achieve its required energy demand.

    MatterSpecification.v13.Cluster § 9.2.4.7

  • ReadonlyforecastAdjustment: BitFlag

    ForecastAdjustment

    ESAs which support the Forecast adjustment feature, allow an EMS to recommend a change to the start, duration and/or power level limits of the steps of the power profile that the ESA has previously suggested it would use.

    Heat pump and Solar PV example: A heat pump may have the ability to heat hot water as well as heating the home. The heat pump scheduling system may have determined that the home will be unoccupied during the day, or that the indoor temperature is above the set-point and so it knows that it will not need to heat the home.

    However, the hot water tank is likely to need to be reheated before the homeowner comes home in the evening. The heat pump is not aware that the property also has a solar PV inverter which is also an ESA that is communicating with the EMS.

    The EMS first requests the Forecast data from each of its registered ESAs. It determines that the heat pump has a power profile suggesting it needs to heat hot water around 6pm. The solar PV inverter has forecast that it will generate 3.6kW of power during the middle of the day and into the afternoon before the sun goes down.

    The EMS can then optimize the home considering other non-ESA loads and can ask the heat pump to heat the hot water around 3pm when it has forecast that excess solar power will be available.

    It does this by sending a ModifyForecastRequest to the heat pump and asks the heat pump to expect to run at a lower power consumption (within the solar excess power) which requires the heat pump to run for a longer duration to achieve its required energy demand.

    MatterSpecification.v13.Cluster § 9.2.4.6

  • Readonlypausable: BitFlag

    Pausable

    ESAs which support the Pausable feature, allow an EMS to recommend a pause in the middle of a forecast power profile that the ESA is currently using.

    Washing machine example: A Washing Machine is in operation, and starting its water heating step.

    However, the EMS becomes aware from the smart meter that the total home load on the grid is close to exceeding its allowed total grid load.

    The EMS first requests the Forecast data from each of its registered ESAs. It determines that the washing machine has a power profile suggesting its current step in the wash cycle is using power to heat the water, but that this step can be paused.

    The EMS can then reduce the grid load by asking the washing machine to pause the wash cycle for a short duration.

    It does this by sending a PauseRequest to the washing machine to request pausing the current step of the forecast power usage for a period to allow other home loads to finish before resuming the washing cycle.

    MatterSpecification.v13.Cluster § 9.2.4.5

  • ReadonlypowerAdjustment: BitFlag

    PowerAdjustment

    For Energy Smart Appliances (ESA) the definition of being 'smart' mandates that they can report their current power adjustment capability and have an EMS request a temporary adjustment. This may typically be to curtail power requirements during peak periods, but can also be used to turn on an ESA if there is excess renewable or local generation (Solar PV).

    For example, a home may have solar PV which often produces more power than the home requires,

    resulting in the excess power flowing into the grid. This excess power naturally fluctuates when clouds pass overhead and other loads in the home are switched on and off.

    EVSE Example: An EMS may therefore be able to turn on the EVSE (if the vehicle is plugged in) and can start charging the vehicle, and periodically modify the charging power depending on PV generation and other home loads, so as to minimize import and export to the grid.

    MatterSpecification.v13.Cluster § 9.2.4.1

  • ReadonlypowerForecastReporting: BitFlag

    PowerForecastReporting

    For Energy Smart Appliances (ESA) the definition of being 'smart' implies that they can report their indicative forecast power demands or generation, to a greater or lesser extent. For some ESAs this is highly predictable (in terms of both power and time), in other appliances this is more challenging and only a basic level of forecast is possible.

    Forecasts are defined from a current time, using a slot format, where the slot is akin to a relatively constant operating mode.

    Washing machine example: a washing machine may have stages of a washing cycle: heating, tumbling, rinse and spin stages. At each stage, the approximate minimum and maximum power consumption may be known, as well as the duration of that stage.

    In some circumstances the ESA may allow the stage to be delayed or paused (subject to safety and manufacturer’s discretion and user preferences).

    Typically, appliances with a heating element cannot have their power consumption adjusted and can only be paused or delayed.

    Some ESAs may not be flexible other than a delayed cycle start (for example, once the washing cycle has been started then they run continuously until the cycle completes).

    Appliances that only support the PowerForecastReporting and not any of the adjustment features may indicate that they are not flexible in the forecast slot format.

    The PowerForecastReporting and the adjustment features aim to align to the [SAREF4ENER] ontology.

    Inverter driven ESAs: some inverter driven ESAs can consume or generate a variable amount of power.

    For example, a single phase EVSE can be adjusted in the range of 6-32Amps in 0.6 Amp steps in EU or on a hardwired 120V supply in the range of 6-15 Amps in US.

    For example, a home battery may be adjusted to charge or discharge in steps of 1W.

    For example, a heat pump may be able to modulate its compressor inverter between 20-100% of its rated power.

    The ESA indicates its power adjustment range and its nominal power consumption as part of its Forecast.

    MatterSpecification.v13.Cluster § 9.2.4.2

  • ReadonlystartTimeAdjustment: BitFlag

    StartTimeAdjustment

    ESAs which support the Start Time Adjustment feature, allow an EMS to recommend a change to the start time of the energy transfer that the ESA has previously suggested it would use.

    Washing machine example: A Washing Machine may have been set to start a wash cycle at 9pm when the variable tariff normally reduces.

    However, the EMS is aware that a grid event has occurred, making it cheaper to run the cycle at a later time, but the washing machine is not aware of this.

    The EMS first requests the Forecast data from each of its registered ESAs. It determines that the washing machine has a power profile suggesting it will start the wash cycle at 9pm, but the EMS now knows that the grid event means it will be cheaper to delay the start until 11pm.

    The EMS can then optimize the cost by asking the washing machine to delay starting the wash cycle until 11pm.

    It does this by sending a StartTimeAdjustRequest to the washing machine to request delaying the start of the washing cycle.

    MatterSpecification.v13.Cluster § 9.2.4.4

  • ReadonlystateForecastReporting: BitFlag

    StateForecastReporting

    Some ESAs do not know their actual power consumption, but do know the state of operation. Like the PowerForecastingReporting feature, this uses the same slot structure mechanism to indicate a change in state vs time.

    An external observing EMS may have access to real-time meter readings, and could learn the typical power consumption based on the advertised internal state of the ESA.

    To enable this capability, the ESA shall report its internal operational state using an manufacturer specific value.

    Once the EMS has built a model of the state vs observed power consumption, it may request a forecast adjustment for particular times of the day, encouraging the ESA to use power at alternative times.

    MatterSpecification.v13.Cluster § 9.2.4.3

id: Branded<152, "ClusterId">
name
revision
supportedFeatures: {}
unknown

Methods

  • Modify elements using ElementModifier.alter.

    Type Parameters

    • const AlterationsT extends Alterations<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>;
              forecast: Attribute<null | TypeFromFields<{
                  activeSlotNumber: FieldType<(...) | (...)>;
                  earliestStartTime: OptionalFieldType<(...) | (...)>;
                  endTime: FieldType<number>;
                  forecastId: FieldType<number>;
                  forecastUpdateReason: FieldType<DeviceEnergyManagement.ForecastUpdateReason>;
                  isPauseable: FieldType<boolean>;
                  latestEndTime: OptionalFieldType<number>;
                  slots: FieldType<(...)[]>;
                  startTime: FieldType<number>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      powerForecastReporting: boolean;
                  }, {
                      stateForecastReporting: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              optOutState: Attribute<DeviceEnergyManagement.OptOutState, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      powerAdjustment: boolean;
                  }, {
                      startTimeAdjustment: boolean;
                  }, {
                      pausable: boolean;
                  }, {
                      forecastAdjustment: boolean;
                  }, {
                      constraintBasedAdjustment: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              powerAdjustmentCapability: Attribute<null | TypeFromFields<{
                  maxDuration: FieldType<(...)>;
                  maxPower: FieldType<(...)>;
                  minDuration: FieldType<(...)>;
                  minPower: FieldType<(...)>;
              }>[], any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      powerAdjustment: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          commands: {
              cancelPowerAdjustRequest: Command<void, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      powerAdjustment: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              cancelRequest: Command<void, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      startTimeAdjustment: boolean;
                  }, {
                      forecastAdjustment: boolean;
                  }, {
                      constraintBasedAdjustment: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              modifyForecastRequest: Command<TypeFromFields<{
                  cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
                  forecastId: FieldType<number>;
                  slotAdjustments: FieldType<TypeFromFields<(...)>[]>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      forecastAdjustment: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              pauseRequest: Command<TypeFromFields<{
                  cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
                  duration: FieldType<number>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      pausable: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              powerAdjustRequest: Command<TypeFromFields<{
                  cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
                  duration: FieldType<number>;
                  power: FieldType<number | bigint>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      powerAdjustment: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              requestConstraintBasedForecast: Command<TypeFromFields<{
                  cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
                  constraints: FieldType<TypeFromFields<(...)>[]>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      constraintBasedAdjustment: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              resumeRequest: Command<void, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      pausable: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              startTimeAdjustRequest: Command<TypeFromFields<{
                  cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
                  requestedStartTime: FieldType<number>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      startTimeAdjustment: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          events: {
              paused: Event<void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      pausable: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              powerAdjustEnd: Event<TypeFromFields<{
                  cause: FieldType<DeviceEnergyManagement.Cause>;
                  duration: FieldType<number>;
                  energyUse: FieldType<number | bigint>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      powerAdjustment: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              powerAdjustStart: Event<void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      powerAdjustment: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              resumed: Event<TypeFromFields<{
                  cause: FieldType<DeviceEnergyManagement.Cause>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      pausable: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          features: {
              constraintBasedAdjustment: BitFlag;
              forecastAdjustment: BitFlag;
              pausable: BitFlag;
              powerAdjustment: BitFlag;
              powerForecastReporting: BitFlag;
              startTimeAdjustment: BitFlag;
              stateForecastReporting: BitFlag;
          };
          id: 152;
          name: "DeviceEnergyManagement";
          revision: 3;
      }>>

    Parameters

    Returns WithAlterations<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>;
            forecast: Attribute<null | TypeFromFields<{
                activeSlotNumber: FieldType<(...) | (...)>;
                earliestStartTime: OptionalFieldType<(...) | (...)>;
                endTime: FieldType<number>;
                forecastId: FieldType<number>;
                forecastUpdateReason: FieldType<DeviceEnergyManagement.ForecastUpdateReason>;
                isPauseable: FieldType<boolean>;
                latestEndTime: OptionalFieldType<number>;
                slots: FieldType<(...)[]>;
                startTime: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerForecastReporting: boolean;
                }, {
                    stateForecastReporting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            optOutState: Attribute<DeviceEnergyManagement.OptOutState, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAdjustment: boolean;
                }, {
                    startTimeAdjustment: boolean;
                }, {
                    pausable: boolean;
                }, {
                    forecastAdjustment: boolean;
                }, {
                    constraintBasedAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            powerAdjustmentCapability: Attribute<null | TypeFromFields<{
                maxDuration: FieldType<(...)>;
                maxPower: FieldType<(...)>;
                minDuration: FieldType<(...)>;
                minPower: FieldType<(...)>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            cancelPowerAdjustRequest: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            cancelRequest: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    startTimeAdjustment: boolean;
                }, {
                    forecastAdjustment: boolean;
                }, {
                    constraintBasedAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            modifyForecastRequest: Command<TypeFromFields<{
                cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
                forecastId: FieldType<number>;
                slotAdjustments: FieldType<TypeFromFields<(...)>[]>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    forecastAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            pauseRequest: Command<TypeFromFields<{
                cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
                duration: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pausable: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            powerAdjustRequest: Command<TypeFromFields<{
                cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
                duration: FieldType<number>;
                power: FieldType<number | bigint>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            requestConstraintBasedForecast: Command<TypeFromFields<{
                cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
                constraints: FieldType<TypeFromFields<(...)>[]>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constraintBasedAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            resumeRequest: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pausable: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            startTimeAdjustRequest: Command<TypeFromFields<{
                cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
                requestedStartTime: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    startTimeAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        events: {
            paused: Event<void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pausable: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            powerAdjustEnd: Event<TypeFromFields<{
                cause: FieldType<DeviceEnergyManagement.Cause>;
                duration: FieldType<number>;
                energyUse: FieldType<number | bigint>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            powerAdjustStart: Event<void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            resumed: Event<TypeFromFields<{
                cause: FieldType<DeviceEnergyManagement.Cause>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pausable: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            constraintBasedAdjustment: BitFlag;
            forecastAdjustment: BitFlag;
            pausable: BitFlag;
            powerAdjustment: BitFlag;
            powerForecastReporting: BitFlag;
            startTimeAdjustment: BitFlag;
            stateForecastReporting: BitFlag;
        };
        id: 152;
        name: "DeviceEnergyManagement";
        revision: 3;
    }>, AlterationsT>

  • Modify elements using ElementModifier.enable.

    Type Parameters

    • const FlagsT extends ElementFlags<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>;
              forecast: Attribute<null | TypeFromFields<{
                  activeSlotNumber: FieldType<(...) | (...)>;
                  earliestStartTime: OptionalFieldType<(...) | (...)>;
                  endTime: FieldType<number>;
                  forecastId: FieldType<number>;
                  forecastUpdateReason: FieldType<DeviceEnergyManagement.ForecastUpdateReason>;
                  isPauseable: FieldType<boolean>;
                  latestEndTime: OptionalFieldType<number>;
                  slots: FieldType<(...)[]>;
                  startTime: FieldType<number>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      powerForecastReporting: boolean;
                  }, {
                      stateForecastReporting: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              optOutState: Attribute<DeviceEnergyManagement.OptOutState, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      powerAdjustment: boolean;
                  }, {
                      startTimeAdjustment: boolean;
                  }, {
                      pausable: boolean;
                  }, {
                      forecastAdjustment: boolean;
                  }, {
                      constraintBasedAdjustment: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              powerAdjustmentCapability: Attribute<null | TypeFromFields<{
                  maxDuration: FieldType<(...)>;
                  maxPower: FieldType<(...)>;
                  minDuration: FieldType<(...)>;
                  minPower: FieldType<(...)>;
              }>[], any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      powerAdjustment: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          commands: {
              cancelPowerAdjustRequest: Command<void, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      powerAdjustment: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              cancelRequest: Command<void, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      startTimeAdjustment: boolean;
                  }, {
                      forecastAdjustment: boolean;
                  }, {
                      constraintBasedAdjustment: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              modifyForecastRequest: Command<TypeFromFields<{
                  cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
                  forecastId: FieldType<number>;
                  slotAdjustments: FieldType<TypeFromFields<(...)>[]>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      forecastAdjustment: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              pauseRequest: Command<TypeFromFields<{
                  cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
                  duration: FieldType<number>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      pausable: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              powerAdjustRequest: Command<TypeFromFields<{
                  cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
                  duration: FieldType<number>;
                  power: FieldType<number | bigint>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      powerAdjustment: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              requestConstraintBasedForecast: Command<TypeFromFields<{
                  cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
                  constraints: FieldType<TypeFromFields<(...)>[]>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      constraintBasedAdjustment: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              resumeRequest: Command<void, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      pausable: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              startTimeAdjustRequest: Command<TypeFromFields<{
                  cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
                  requestedStartTime: FieldType<number>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      startTimeAdjustment: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          events: {
              paused: Event<void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      pausable: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              powerAdjustEnd: Event<TypeFromFields<{
                  cause: FieldType<DeviceEnergyManagement.Cause>;
                  duration: FieldType<number>;
                  energyUse: FieldType<number | bigint>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      powerAdjustment: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              powerAdjustStart: Event<void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      powerAdjustment: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              resumed: Event<TypeFromFields<{
                  cause: FieldType<DeviceEnergyManagement.Cause>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      pausable: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          features: {
              constraintBasedAdjustment: BitFlag;
              forecastAdjustment: BitFlag;
              pausable: BitFlag;
              powerAdjustment: BitFlag;
              powerForecastReporting: BitFlag;
              startTimeAdjustment: BitFlag;
              stateForecastReporting: BitFlag;
          };
          id: 152;
          name: "DeviceEnergyManagement";
          revision: 3;
      }>>

    Parameters

    Returns WithFlags<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>;
            forecast: Attribute<null | TypeFromFields<{
                activeSlotNumber: FieldType<(...) | (...)>;
                earliestStartTime: OptionalFieldType<(...) | (...)>;
                endTime: FieldType<number>;
                forecastId: FieldType<number>;
                forecastUpdateReason: FieldType<DeviceEnergyManagement.ForecastUpdateReason>;
                isPauseable: FieldType<boolean>;
                latestEndTime: OptionalFieldType<number>;
                slots: FieldType<(...)[]>;
                startTime: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerForecastReporting: boolean;
                }, {
                    stateForecastReporting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            optOutState: Attribute<DeviceEnergyManagement.OptOutState, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAdjustment: boolean;
                }, {
                    startTimeAdjustment: boolean;
                }, {
                    pausable: boolean;
                }, {
                    forecastAdjustment: boolean;
                }, {
                    constraintBasedAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            powerAdjustmentCapability: Attribute<null | TypeFromFields<{
                maxDuration: FieldType<(...)>;
                maxPower: FieldType<(...)>;
                minDuration: FieldType<(...)>;
                minPower: FieldType<(...)>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            cancelPowerAdjustRequest: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            cancelRequest: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    startTimeAdjustment: boolean;
                }, {
                    forecastAdjustment: boolean;
                }, {
                    constraintBasedAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            modifyForecastRequest: Command<TypeFromFields<{
                cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
                forecastId: FieldType<number>;
                slotAdjustments: FieldType<TypeFromFields<(...)>[]>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    forecastAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            pauseRequest: Command<TypeFromFields<{
                cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
                duration: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pausable: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            powerAdjustRequest: Command<TypeFromFields<{
                cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
                duration: FieldType<number>;
                power: FieldType<number | bigint>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            requestConstraintBasedForecast: Command<TypeFromFields<{
                cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
                constraints: FieldType<TypeFromFields<(...)>[]>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constraintBasedAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            resumeRequest: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pausable: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            startTimeAdjustRequest: Command<TypeFromFields<{
                cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
                requestedStartTime: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    startTimeAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        events: {
            paused: Event<void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pausable: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            powerAdjustEnd: Event<TypeFromFields<{
                cause: FieldType<DeviceEnergyManagement.Cause>;
                duration: FieldType<number>;
                energyUse: FieldType<number | bigint>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            powerAdjustStart: Event<void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            resumed: Event<TypeFromFields<{
                cause: FieldType<DeviceEnergyManagement.Cause>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pausable: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            constraintBasedAdjustment: BitFlag;
            forecastAdjustment: BitFlag;
            pausable: BitFlag;
            powerAdjustment: BitFlag;
            powerForecastReporting: BitFlag;
            startTimeAdjustment: BitFlag;
            stateForecastReporting: BitFlag;
        };
        id: 152;
        name: "DeviceEnergyManagement";
        revision: 3;
    }>, FlagsT>

  • Modify elements using ElementModifier.set.

    Type Parameters

    • const ValuesT extends {
          absMaxPower: number | bigint;
          absMinPower: number | bigint;
          esaCanGenerate: boolean;
          esaState: number;
          esaType: number;
          forecast?: null | {
              activeSlotNumber: null | number;
              earliestStartTime?: null | number;
              endTime: number;
              forecastId: number;
              forecastUpdateReason: number;
              isPauseable: boolean;
              latestEndTime?: number;
              slots: {
                  costs?: {
                      costType: number;
                      currency?: number;
                      decimalPoints: number;
                      value: number;
                  }[];
                  defaultDuration: number;
                  elapsedSlotTime: number;
                  manufacturerEsaState?: number;
                  maxDuration: number;
                  maxDurationAdjustment?: number;
                  maxPauseDuration?: number;
                  maxPower?: number | bigint;
                  maxPowerAdjustment?: number | bigint;
                  minDuration: number;
                  minDurationAdjustment?: number;
                  minPauseDuration?: number;
                  minPower?: number | bigint;
                  minPowerAdjustment?: number | bigint;
                  nominalEnergy?: number | bigint;
                  nominalPower?: number | bigint;
                  remainingSlotTime: number;
                  slotIsPauseable?: boolean;
              }[];
              startTime: number;
          };
          optOutState?: number;
          powerAdjustmentCapability?: null | {
              maxDuration: number;
              maxPower: number | bigint;
              minDuration: number;
              minPower: number | bigint;
          }[];
      }

    Parameters

    Returns WithValues<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>;
            forecast: Attribute<null | TypeFromFields<{
                activeSlotNumber: FieldType<(...) | (...)>;
                earliestStartTime: OptionalFieldType<(...) | (...)>;
                endTime: FieldType<number>;
                forecastId: FieldType<number>;
                forecastUpdateReason: FieldType<DeviceEnergyManagement.ForecastUpdateReason>;
                isPauseable: FieldType<boolean>;
                latestEndTime: OptionalFieldType<number>;
                slots: FieldType<(...)[]>;
                startTime: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerForecastReporting: boolean;
                }, {
                    stateForecastReporting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            optOutState: Attribute<DeviceEnergyManagement.OptOutState, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAdjustment: boolean;
                }, {
                    startTimeAdjustment: boolean;
                }, {
                    pausable: boolean;
                }, {
                    forecastAdjustment: boolean;
                }, {
                    constraintBasedAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            powerAdjustmentCapability: Attribute<null | TypeFromFields<{
                maxDuration: FieldType<(...)>;
                maxPower: FieldType<(...)>;
                minDuration: FieldType<(...)>;
                minPower: FieldType<(...)>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            cancelPowerAdjustRequest: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            cancelRequest: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    startTimeAdjustment: boolean;
                }, {
                    forecastAdjustment: boolean;
                }, {
                    constraintBasedAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            modifyForecastRequest: Command<TypeFromFields<{
                cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
                forecastId: FieldType<number>;
                slotAdjustments: FieldType<TypeFromFields<(...)>[]>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    forecastAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            pauseRequest: Command<TypeFromFields<{
                cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
                duration: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pausable: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            powerAdjustRequest: Command<TypeFromFields<{
                cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
                duration: FieldType<number>;
                power: FieldType<number | bigint>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            requestConstraintBasedForecast: Command<TypeFromFields<{
                cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
                constraints: FieldType<TypeFromFields<(...)>[]>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constraintBasedAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            resumeRequest: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pausable: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            startTimeAdjustRequest: Command<TypeFromFields<{
                cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
                requestedStartTime: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    startTimeAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        events: {
            paused: Event<void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pausable: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            powerAdjustEnd: Event<TypeFromFields<{
                cause: FieldType<DeviceEnergyManagement.Cause>;
                duration: FieldType<number>;
                energyUse: FieldType<number | bigint>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            powerAdjustStart: Event<void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            resumed: Event<TypeFromFields<{
                cause: FieldType<DeviceEnergyManagement.Cause>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pausable: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            constraintBasedAdjustment: BitFlag;
            forecastAdjustment: BitFlag;
            pausable: BitFlag;
            powerAdjustment: BitFlag;
            powerForecastReporting: BitFlag;
            startTimeAdjustment: BitFlag;
            stateForecastReporting: BitFlag;
        };
        id: 152;
        name: "DeviceEnergyManagement";
        revision: 3;
    }>, ValuesT>

  • 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>;
              forecast: Attribute<null | TypeFromFields<{
                  activeSlotNumber: FieldType<(...) | (...)>;
                  earliestStartTime: OptionalFieldType<(...) | (...)>;
                  endTime: FieldType<number>;
                  forecastId: FieldType<number>;
                  forecastUpdateReason: FieldType<DeviceEnergyManagement.ForecastUpdateReason>;
                  isPauseable: FieldType<boolean>;
                  latestEndTime: OptionalFieldType<number>;
                  slots: FieldType<(...)[]>;
                  startTime: FieldType<number>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      powerForecastReporting: boolean;
                  }, {
                      stateForecastReporting: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              optOutState: Attribute<DeviceEnergyManagement.OptOutState, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      powerAdjustment: boolean;
                  }, {
                      startTimeAdjustment: boolean;
                  }, {
                      pausable: boolean;
                  }, {
                      forecastAdjustment: boolean;
                  }, {
                      constraintBasedAdjustment: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              powerAdjustmentCapability: Attribute<null | TypeFromFields<{
                  maxDuration: FieldType<(...)>;
                  maxPower: FieldType<(...)>;
                  minDuration: FieldType<(...)>;
                  minPower: FieldType<(...)>;
              }>[], any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      powerAdjustment: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          commands: {
              cancelPowerAdjustRequest: Command<void, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      powerAdjustment: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              cancelRequest: Command<void, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      startTimeAdjustment: boolean;
                  }, {
                      forecastAdjustment: boolean;
                  }, {
                      constraintBasedAdjustment: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              modifyForecastRequest: Command<TypeFromFields<{
                  cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
                  forecastId: FieldType<number>;
                  slotAdjustments: FieldType<TypeFromFields<(...)>[]>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      forecastAdjustment: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              pauseRequest: Command<TypeFromFields<{
                  cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
                  duration: FieldType<number>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      pausable: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              powerAdjustRequest: Command<TypeFromFields<{
                  cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
                  duration: FieldType<number>;
                  power: FieldType<number | bigint>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      powerAdjustment: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              requestConstraintBasedForecast: Command<TypeFromFields<{
                  cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
                  constraints: FieldType<TypeFromFields<(...)>[]>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      constraintBasedAdjustment: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              resumeRequest: Command<void, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      pausable: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              startTimeAdjustRequest: Command<TypeFromFields<{
                  cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
                  requestedStartTime: FieldType<number>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      startTimeAdjustment: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          events: {
              paused: Event<void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      pausable: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              powerAdjustEnd: Event<TypeFromFields<{
                  cause: FieldType<DeviceEnergyManagement.Cause>;
                  duration: FieldType<number>;
                  energyUse: FieldType<number | bigint>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      powerAdjustment: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              powerAdjustStart: Event<void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      powerAdjustment: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              resumed: Event<TypeFromFields<{
                  cause: FieldType<DeviceEnergyManagement.Cause>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      pausable: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          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>;
            forecast: Attribute<null | TypeFromFields<{
                activeSlotNumber: FieldType<(...) | (...)>;
                earliestStartTime: OptionalFieldType<(...) | (...)>;
                endTime: FieldType<number>;
                forecastId: FieldType<number>;
                forecastUpdateReason: FieldType<DeviceEnergyManagement.ForecastUpdateReason>;
                isPauseable: FieldType<boolean>;
                latestEndTime: OptionalFieldType<number>;
                slots: FieldType<(...)[]>;
                startTime: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerForecastReporting: boolean;
                }, {
                    stateForecastReporting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            optOutState: Attribute<DeviceEnergyManagement.OptOutState, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAdjustment: boolean;
                }, {
                    startTimeAdjustment: boolean;
                }, {
                    pausable: boolean;
                }, {
                    forecastAdjustment: boolean;
                }, {
                    constraintBasedAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            powerAdjustmentCapability: Attribute<null | TypeFromFields<{
                maxDuration: FieldType<(...)>;
                maxPower: FieldType<(...)>;
                minDuration: FieldType<(...)>;
                minPower: FieldType<(...)>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            cancelPowerAdjustRequest: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            cancelRequest: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    startTimeAdjustment: boolean;
                }, {
                    forecastAdjustment: boolean;
                }, {
                    constraintBasedAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            modifyForecastRequest: Command<TypeFromFields<{
                cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
                forecastId: FieldType<number>;
                slotAdjustments: FieldType<TypeFromFields<(...)>[]>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    forecastAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            pauseRequest: Command<TypeFromFields<{
                cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
                duration: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pausable: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            powerAdjustRequest: Command<TypeFromFields<{
                cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
                duration: FieldType<number>;
                power: FieldType<number | bigint>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            requestConstraintBasedForecast: Command<TypeFromFields<{
                cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
                constraints: FieldType<TypeFromFields<(...)>[]>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constraintBasedAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            resumeRequest: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pausable: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            startTimeAdjustRequest: Command<TypeFromFields<{
                cause: FieldType<DeviceEnergyManagement.AdjustmentCause>;
                requestedStartTime: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    startTimeAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        events: {
            paused: Event<void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pausable: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            powerAdjustEnd: Event<TypeFromFields<{
                cause: FieldType<DeviceEnergyManagement.Cause>;
                duration: FieldType<number>;
                energyUse: FieldType<number | bigint>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            powerAdjustStart: Event<void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAdjustment: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            resumed: Event<TypeFromFields<{
                cause: FieldType<DeviceEnergyManagement.Cause>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pausable: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            constraintBasedAdjustment: BitFlag;
            forecastAdjustment: BitFlag;
            pausable: BitFlag;
            powerAdjustment: BitFlag;
            powerForecastReporting: BitFlag;
            startTimeAdjustment: BitFlag;
            stateForecastReporting: BitFlag;
        };
        id: 152;
        name: "DeviceEnergyManagement";
        revision: 3;
    }>, SelectionT>