Variable DeviceEnergyManagementBehaviorConst

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

DeviceEnergyManagementBehavior is the base class for objects that support interaction with DeviceEnergyManagement.Cluster.

DeviceEnergyManagement.Cluster requires you to enable one or more optional features. You can do so using DeviceEnergyManagementBehavior.with.

Settings

Member Visibility