Interface Complete

This cluster supports all EnergyEvse 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<{
        acceptedCommandList: Attribute<CommandId[], never>;
        approximateEvEfficiency: OptionalWritableAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                chargingPreferences: boolean;
            }];
        };
        attributeList: Attribute<AttributeId[], never>;
        batteryCapacity: Attribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                soCReporting: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        chargingEnabledUntil: Attribute<null | number, any>;
        circuitCapacity: Attribute<number | bigint, any>;
        clusterRevision: Attribute<number, never>;
        dischargingEnabledUntil: Attribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                v2X: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        faultState: Attribute<EnergyEvse.FaultState, any>;
        featureMap: Attribute<TypeFromPartialBitSchema<{
            chargingPreferences: BitFlag;
            plugAndCharge: BitFlag;
            rfid: BitFlag;
            soCReporting: BitFlag;
            v2X: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        maximumChargeCurrent: Attribute<number | bigint, any>;
        maximumDischargeCurrent: Attribute<number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                v2X: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        minimumChargeCurrent: Attribute<number | bigint, any>;
        nextChargeRequiredEnergy: Attribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                chargingPreferences: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        nextChargeStartTime: Attribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                chargingPreferences: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        nextChargeTargetSoC: Attribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                chargingPreferences: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        nextChargeTargetTime: Attribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                chargingPreferences: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        randomizationDelayWindow: OptionalWritableAttribute<number, any>;
        sessionDuration: Attribute<null | number, any>;
        sessionEnergyCharged: Attribute<null | number | bigint, any>;
        sessionEnergyDischarged: Attribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                v2X: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        sessionId: Attribute<null | number, any>;
        state: Attribute<null | EnergyEvse.State, any>;
        stateOfCharge: Attribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                soCReporting: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        supplyState: Attribute<EnergyEvse.SupplyState, any>;
        userMaximumChargeCurrent: OptionalWritableAttribute<number | bigint, any>;
        vehicleId: Attribute<null | string, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                plugAndCharge: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    }, GlobalAttributes<{
        chargingPreferences: BitFlag;
        plugAndCharge: BitFlag;
        rfid: BitFlag;
        soCReporting: BitFlag;
        v2X: BitFlag;
    }>>;
    base: undefined;
    commands: {
        clearTargets: Command<void, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                chargingPreferences: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        disable: Command<void, void, any>;
        enableCharging: Command<TypeFromFields<{
            chargingEnabledUntil: FieldType<null | number>;
            maximumChargeCurrent: FieldType<number | bigint>;
            minimumChargeCurrent: FieldType<number | bigint>;
        }>, void, any>;
        enableDischarging: Command<TypeFromFields<{
            dischargingEnabledUntil: FieldType<null | number>;
            maximumDischargeCurrent: FieldType<number | bigint>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                v2X: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        getTargets: Command<void, TypeFromFields<{
            chargingTargetSchedules: FieldType<TypeFromFields<{
                chargingTargets: OptionalFieldType<(...)[]>;
                dayOfWeekForSequence: OptionalFieldType<TypeFromPartialBitSchema<(...)>>;
            }>[]>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                chargingPreferences: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        setTargets: Command<TypeFromFields<{
            chargingTargetSchedules: FieldType<TypeFromFields<{
                chargingTargets: OptionalFieldType<(...)[]>;
                dayOfWeekForSequence: OptionalFieldType<TypeFromPartialBitSchema<(...)>>;
            }>[]>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                chargingPreferences: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        startDiagnostics: OptionalCommand<void, void, any>;
    };
    events: {
        energyTransferStarted: Event<TypeFromFields<{
            maximumCurrent: FieldType<number | bigint>;
            sessionId: FieldType<number>;
            state: FieldType<EnergyEvse.State>;
        }>, any>;
        energyTransferStopped: Event<TypeFromFields<{
            energyTransferred: FieldType<number | bigint>;
            reason: FieldType<EnergyEvse.EnergyTransferStoppedReason>;
            sessionId: FieldType<number>;
            state: FieldType<EnergyEvse.State>;
        }>, any>;
        evConnected: Event<TypeFromFields<{
            sessionId: FieldType<number>;
        }>, any>;
        evNotDetected: Event<TypeFromFields<{
            sessionDuration: FieldType<number>;
            sessionEnergyCharged: FieldType<number | bigint>;
            sessionEnergyDischarged: OptionalFieldType<number | bigint>;
            sessionId: FieldType<number>;
            state: FieldType<EnergyEvse.State>;
        }>, any>;
        fault: Event<TypeFromFields<{
            faultStateCurrentState: FieldType<EnergyEvse.FaultState>;
            faultStatePreviousState: FieldType<EnergyEvse.FaultState>;
            sessionId: FieldType<null | number>;
            state: FieldType<EnergyEvse.State>;
        }>, any>;
        rfid: OptionalEvent<TypeFromFields<{
            uid: FieldType<Uint8Array>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                rfid: boolean;
            }];
        };
    };
    extensions: undefined;
    features: {
        chargingPreferences: BitFlag;
        plugAndCharge: BitFlag;
        rfid: BitFlag;
        soCReporting: BitFlag;
        v2X: BitFlag;
    };
    id: Branded<Branded<153, "ClusterId">, "ClusterId">;
    name: "EnergyEvse";
    revision: 2;
    supportedFeatures: {};
    unknown: false;
    alter<const AlterationsT>(alterations: AlterationsT): WithAlterations<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            approximateEvEfficiency: OptionalWritableAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    chargingPreferences: boolean;
                }];
            };
            attributeList: Attribute<AttributeId[], never>;
            batteryCapacity: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    soCReporting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            chargingEnabledUntil: Attribute<null | number, any>;
            circuitCapacity: Attribute<number | bigint, any>;
            clusterRevision: Attribute<number, never>;
            dischargingEnabledUntil: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    v2X: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            faultState: Attribute<EnergyEvse.FaultState, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                chargingPreferences: BitFlag;
                plugAndCharge: BitFlag;
                rfid: BitFlag;
                soCReporting: BitFlag;
                v2X: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maximumChargeCurrent: Attribute<number | bigint, any>;
            maximumDischargeCurrent: Attribute<number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    v2X: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minimumChargeCurrent: Attribute<number | bigint, any>;
            nextChargeRequiredEnergy: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            nextChargeStartTime: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            nextChargeTargetSoC: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            nextChargeTargetTime: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            randomizationDelayWindow: OptionalWritableAttribute<number, any>;
            sessionDuration: Attribute<null | number, any>;
            sessionEnergyCharged: Attribute<null | number | bigint, any>;
            sessionEnergyDischarged: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    v2X: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            sessionId: Attribute<null | number, any>;
            state: Attribute<null | EnergyEvse.State, any>;
            stateOfCharge: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    soCReporting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supplyState: Attribute<EnergyEvse.SupplyState, any>;
            userMaximumChargeCurrent: OptionalWritableAttribute<number | bigint, any>;
            vehicleId: Attribute<null | string, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    plugAndCharge: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            clearTargets: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            disable: Command<void, void, any>;
            enableCharging: Command<TypeFromFields<{
                chargingEnabledUntil: FieldType<null | number>;
                maximumChargeCurrent: FieldType<number | bigint>;
                minimumChargeCurrent: FieldType<number | bigint>;
            }>, void, any>;
            enableDischarging: Command<TypeFromFields<{
                dischargingEnabledUntil: FieldType<null | number>;
                maximumDischargeCurrent: FieldType<number | bigint>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    v2X: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getTargets: Command<void, TypeFromFields<{
                chargingTargetSchedules: FieldType<TypeFromFields<(...)>[]>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setTargets: Command<TypeFromFields<{
                chargingTargetSchedules: FieldType<TypeFromFields<(...)>[]>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            startDiagnostics: OptionalCommand<void, void, any>;
        };
        events: {
            energyTransferStarted: Event<TypeFromFields<{
                maximumCurrent: FieldType<number | bigint>;
                sessionId: FieldType<number>;
                state: FieldType<EnergyEvse.State>;
            }>, any>;
            energyTransferStopped: Event<TypeFromFields<{
                energyTransferred: FieldType<number | bigint>;
                reason: FieldType<EnergyEvse.EnergyTransferStoppedReason>;
                sessionId: FieldType<number>;
                state: FieldType<EnergyEvse.State>;
            }>, any>;
            evConnected: Event<TypeFromFields<{
                sessionId: FieldType<number>;
            }>, any>;
            evNotDetected: Event<TypeFromFields<{
                sessionDuration: FieldType<number>;
                sessionEnergyCharged: FieldType<number | bigint>;
                sessionEnergyDischarged: OptionalFieldType<number | bigint>;
                sessionId: FieldType<number>;
                state: FieldType<EnergyEvse.State>;
            }>, any>;
            fault: Event<TypeFromFields<{
                faultStateCurrentState: FieldType<EnergyEvse.FaultState>;
                faultStatePreviousState: FieldType<EnergyEvse.FaultState>;
                sessionId: FieldType<null | number>;
                state: FieldType<EnergyEvse.State>;
            }>, any>;
            rfid: OptionalEvent<TypeFromFields<{
                uid: FieldType<Uint8Array>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    rfid: boolean;
                }];
            };
        };
        features: {
            chargingPreferences: BitFlag;
            plugAndCharge: BitFlag;
            rfid: BitFlag;
            soCReporting: BitFlag;
            v2X: BitFlag;
        };
        id: Branded<153, "ClusterId">;
        name: "EnergyEvse";
        revision: 2;
    }>, AlterationsT>;
    enable<const FlagsT>(flags: FlagsT): WithFlags<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            approximateEvEfficiency: OptionalWritableAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    chargingPreferences: boolean;
                }];
            };
            attributeList: Attribute<AttributeId[], never>;
            batteryCapacity: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    soCReporting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            chargingEnabledUntil: Attribute<null | number, any>;
            circuitCapacity: Attribute<number | bigint, any>;
            clusterRevision: Attribute<number, never>;
            dischargingEnabledUntil: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    v2X: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            faultState: Attribute<EnergyEvse.FaultState, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                chargingPreferences: BitFlag;
                plugAndCharge: BitFlag;
                rfid: BitFlag;
                soCReporting: BitFlag;
                v2X: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maximumChargeCurrent: Attribute<number | bigint, any>;
            maximumDischargeCurrent: Attribute<number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    v2X: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minimumChargeCurrent: Attribute<number | bigint, any>;
            nextChargeRequiredEnergy: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            nextChargeStartTime: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            nextChargeTargetSoC: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            nextChargeTargetTime: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            randomizationDelayWindow: OptionalWritableAttribute<number, any>;
            sessionDuration: Attribute<null | number, any>;
            sessionEnergyCharged: Attribute<null | number | bigint, any>;
            sessionEnergyDischarged: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    v2X: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            sessionId: Attribute<null | number, any>;
            state: Attribute<null | EnergyEvse.State, any>;
            stateOfCharge: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    soCReporting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supplyState: Attribute<EnergyEvse.SupplyState, any>;
            userMaximumChargeCurrent: OptionalWritableAttribute<number | bigint, any>;
            vehicleId: Attribute<null | string, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    plugAndCharge: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            clearTargets: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            disable: Command<void, void, any>;
            enableCharging: Command<TypeFromFields<{
                chargingEnabledUntil: FieldType<null | number>;
                maximumChargeCurrent: FieldType<number | bigint>;
                minimumChargeCurrent: FieldType<number | bigint>;
            }>, void, any>;
            enableDischarging: Command<TypeFromFields<{
                dischargingEnabledUntil: FieldType<null | number>;
                maximumDischargeCurrent: FieldType<number | bigint>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    v2X: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getTargets: Command<void, TypeFromFields<{
                chargingTargetSchedules: FieldType<TypeFromFields<(...)>[]>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setTargets: Command<TypeFromFields<{
                chargingTargetSchedules: FieldType<TypeFromFields<(...)>[]>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            startDiagnostics: OptionalCommand<void, void, any>;
        };
        events: {
            energyTransferStarted: Event<TypeFromFields<{
                maximumCurrent: FieldType<number | bigint>;
                sessionId: FieldType<number>;
                state: FieldType<EnergyEvse.State>;
            }>, any>;
            energyTransferStopped: Event<TypeFromFields<{
                energyTransferred: FieldType<number | bigint>;
                reason: FieldType<EnergyEvse.EnergyTransferStoppedReason>;
                sessionId: FieldType<number>;
                state: FieldType<EnergyEvse.State>;
            }>, any>;
            evConnected: Event<TypeFromFields<{
                sessionId: FieldType<number>;
            }>, any>;
            evNotDetected: Event<TypeFromFields<{
                sessionDuration: FieldType<number>;
                sessionEnergyCharged: FieldType<number | bigint>;
                sessionEnergyDischarged: OptionalFieldType<number | bigint>;
                sessionId: FieldType<number>;
                state: FieldType<EnergyEvse.State>;
            }>, any>;
            fault: Event<TypeFromFields<{
                faultStateCurrentState: FieldType<EnergyEvse.FaultState>;
                faultStatePreviousState: FieldType<EnergyEvse.FaultState>;
                sessionId: FieldType<null | number>;
                state: FieldType<EnergyEvse.State>;
            }>, any>;
            rfid: OptionalEvent<TypeFromFields<{
                uid: FieldType<Uint8Array>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    rfid: boolean;
                }];
            };
        };
        features: {
            chargingPreferences: BitFlag;
            plugAndCharge: BitFlag;
            rfid: BitFlag;
            soCReporting: BitFlag;
            v2X: BitFlag;
        };
        id: Branded<153, "ClusterId">;
        name: "EnergyEvse";
        revision: 2;
    }>, FlagsT>;
    set<const ValuesT>(values: ValuesT): WithValues<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            approximateEvEfficiency: OptionalWritableAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    chargingPreferences: boolean;
                }];
            };
            attributeList: Attribute<AttributeId[], never>;
            batteryCapacity: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    soCReporting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            chargingEnabledUntil: Attribute<null | number, any>;
            circuitCapacity: Attribute<number | bigint, any>;
            clusterRevision: Attribute<number, never>;
            dischargingEnabledUntil: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    v2X: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            faultState: Attribute<EnergyEvse.FaultState, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                chargingPreferences: BitFlag;
                plugAndCharge: BitFlag;
                rfid: BitFlag;
                soCReporting: BitFlag;
                v2X: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maximumChargeCurrent: Attribute<number | bigint, any>;
            maximumDischargeCurrent: Attribute<number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    v2X: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minimumChargeCurrent: Attribute<number | bigint, any>;
            nextChargeRequiredEnergy: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            nextChargeStartTime: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            nextChargeTargetSoC: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            nextChargeTargetTime: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            randomizationDelayWindow: OptionalWritableAttribute<number, any>;
            sessionDuration: Attribute<null | number, any>;
            sessionEnergyCharged: Attribute<null | number | bigint, any>;
            sessionEnergyDischarged: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    v2X: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            sessionId: Attribute<null | number, any>;
            state: Attribute<null | EnergyEvse.State, any>;
            stateOfCharge: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    soCReporting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supplyState: Attribute<EnergyEvse.SupplyState, any>;
            userMaximumChargeCurrent: OptionalWritableAttribute<number | bigint, any>;
            vehicleId: Attribute<null | string, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    plugAndCharge: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            clearTargets: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            disable: Command<void, void, any>;
            enableCharging: Command<TypeFromFields<{
                chargingEnabledUntil: FieldType<null | number>;
                maximumChargeCurrent: FieldType<number | bigint>;
                minimumChargeCurrent: FieldType<number | bigint>;
            }>, void, any>;
            enableDischarging: Command<TypeFromFields<{
                dischargingEnabledUntil: FieldType<null | number>;
                maximumDischargeCurrent: FieldType<number | bigint>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    v2X: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getTargets: Command<void, TypeFromFields<{
                chargingTargetSchedules: FieldType<TypeFromFields<(...)>[]>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setTargets: Command<TypeFromFields<{
                chargingTargetSchedules: FieldType<TypeFromFields<(...)>[]>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            startDiagnostics: OptionalCommand<void, void, any>;
        };
        events: {
            energyTransferStarted: Event<TypeFromFields<{
                maximumCurrent: FieldType<number | bigint>;
                sessionId: FieldType<number>;
                state: FieldType<EnergyEvse.State>;
            }>, any>;
            energyTransferStopped: Event<TypeFromFields<{
                energyTransferred: FieldType<number | bigint>;
                reason: FieldType<EnergyEvse.EnergyTransferStoppedReason>;
                sessionId: FieldType<number>;
                state: FieldType<EnergyEvse.State>;
            }>, any>;
            evConnected: Event<TypeFromFields<{
                sessionId: FieldType<number>;
            }>, any>;
            evNotDetected: Event<TypeFromFields<{
                sessionDuration: FieldType<number>;
                sessionEnergyCharged: FieldType<number | bigint>;
                sessionEnergyDischarged: OptionalFieldType<number | bigint>;
                sessionId: FieldType<number>;
                state: FieldType<EnergyEvse.State>;
            }>, any>;
            fault: Event<TypeFromFields<{
                faultStateCurrentState: FieldType<EnergyEvse.FaultState>;
                faultStatePreviousState: FieldType<EnergyEvse.FaultState>;
                sessionId: FieldType<null | number>;
                state: FieldType<EnergyEvse.State>;
            }>, any>;
            rfid: OptionalEvent<TypeFromFields<{
                uid: FieldType<Uint8Array>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    rfid: boolean;
                }];
            };
        };
        features: {
            chargingPreferences: BitFlag;
            plugAndCharge: BitFlag;
            rfid: BitFlag;
            soCReporting: BitFlag;
            v2X: BitFlag;
        };
        id: Branded<153, "ClusterId">;
        name: "EnergyEvse";
        revision: 2;
    }>, ValuesT>;
    with<const SelectionT>(...selection: SelectionT): Of<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            approximateEvEfficiency: OptionalWritableAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    chargingPreferences: boolean;
                }];
            };
            attributeList: Attribute<AttributeId[], never>;
            batteryCapacity: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    soCReporting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            chargingEnabledUntil: Attribute<null | number, any>;
            circuitCapacity: Attribute<number | bigint, any>;
            clusterRevision: Attribute<number, never>;
            dischargingEnabledUntil: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    v2X: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            faultState: Attribute<EnergyEvse.FaultState, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                chargingPreferences: BitFlag;
                plugAndCharge: BitFlag;
                rfid: BitFlag;
                soCReporting: BitFlag;
                v2X: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maximumChargeCurrent: Attribute<number | bigint, any>;
            maximumDischargeCurrent: Attribute<number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    v2X: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minimumChargeCurrent: Attribute<number | bigint, any>;
            nextChargeRequiredEnergy: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            nextChargeStartTime: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            nextChargeTargetSoC: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            nextChargeTargetTime: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            randomizationDelayWindow: OptionalWritableAttribute<number, any>;
            sessionDuration: Attribute<null | number, any>;
            sessionEnergyCharged: Attribute<null | number | bigint, any>;
            sessionEnergyDischarged: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    v2X: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            sessionId: Attribute<null | number, any>;
            state: Attribute<null | EnergyEvse.State, any>;
            stateOfCharge: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    soCReporting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supplyState: Attribute<EnergyEvse.SupplyState, any>;
            userMaximumChargeCurrent: OptionalWritableAttribute<number | bigint, any>;
            vehicleId: Attribute<null | string, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    plugAndCharge: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            clearTargets: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            disable: Command<void, void, any>;
            enableCharging: Command<TypeFromFields<{
                chargingEnabledUntil: FieldType<null | number>;
                maximumChargeCurrent: FieldType<number | bigint>;
                minimumChargeCurrent: FieldType<number | bigint>;
            }>, void, any>;
            enableDischarging: Command<TypeFromFields<{
                dischargingEnabledUntil: FieldType<null | number>;
                maximumDischargeCurrent: FieldType<number | bigint>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    v2X: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getTargets: Command<void, TypeFromFields<{
                chargingTargetSchedules: FieldType<TypeFromFields<(...)>[]>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setTargets: Command<TypeFromFields<{
                chargingTargetSchedules: FieldType<TypeFromFields<(...)>[]>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            startDiagnostics: OptionalCommand<void, void, any>;
        };
        events: {
            energyTransferStarted: Event<TypeFromFields<{
                maximumCurrent: FieldType<number | bigint>;
                sessionId: FieldType<number>;
                state: FieldType<EnergyEvse.State>;
            }>, any>;
            energyTransferStopped: Event<TypeFromFields<{
                energyTransferred: FieldType<number | bigint>;
                reason: FieldType<EnergyEvse.EnergyTransferStoppedReason>;
                sessionId: FieldType<number>;
                state: FieldType<EnergyEvse.State>;
            }>, any>;
            evConnected: Event<TypeFromFields<{
                sessionId: FieldType<number>;
            }>, any>;
            evNotDetected: Event<TypeFromFields<{
                sessionDuration: FieldType<number>;
                sessionEnergyCharged: FieldType<number | bigint>;
                sessionEnergyDischarged: OptionalFieldType<number | bigint>;
                sessionId: FieldType<number>;
                state: FieldType<EnergyEvse.State>;
            }>, any>;
            fault: Event<TypeFromFields<{
                faultStateCurrentState: FieldType<EnergyEvse.FaultState>;
                faultStatePreviousState: FieldType<EnergyEvse.FaultState>;
                sessionId: FieldType<null | number>;
                state: FieldType<EnergyEvse.State>;
            }>, any>;
            rfid: OptionalEvent<TypeFromFields<{
                uid: FieldType<Uint8Array>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    rfid: boolean;
                }];
            };
        };
        features: {
            chargingPreferences: BitFlag;
            plugAndCharge: BitFlag;
            rfid: BitFlag;
            soCReporting: BitFlag;
            v2X: BitFlag;
        };
        id: Branded<153, "ClusterId">;
        name: "EnergyEvse";
        revision: 2;
    }>, SelectionT>;
}

Hierarchy (view full)

Properties

attributes base commands events extensions features id name revision supportedFeatures unknown

Methods

alter enable set with

Properties

attributes

attributes: Merge<{
    acceptedCommandList: Attribute<CommandId[], never>;
    approximateEvEfficiency: OptionalWritableAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            chargingPreferences: boolean;
        }];
    };
    attributeList: Attribute<AttributeId[], never>;
    batteryCapacity: Attribute<null | number | bigint, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            soCReporting: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    chargingEnabledUntil: Attribute<null | number, any>;
    circuitCapacity: Attribute<number | bigint, any>;
    clusterRevision: Attribute<number, never>;
    dischargingEnabledUntil: Attribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            v2X: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    faultState: Attribute<EnergyEvse.FaultState, any>;
    featureMap: Attribute<TypeFromPartialBitSchema<{
        chargingPreferences: BitFlag;
        plugAndCharge: BitFlag;
        rfid: BitFlag;
        soCReporting: BitFlag;
        v2X: BitFlag;
    }>, never>;
    generatedCommandList: Attribute<CommandId[], never>;
    maximumChargeCurrent: Attribute<number | bigint, any>;
    maximumDischargeCurrent: Attribute<number | bigint, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            v2X: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    minimumChargeCurrent: Attribute<number | bigint, any>;
    nextChargeRequiredEnergy: Attribute<null | number | bigint, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            chargingPreferences: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    nextChargeStartTime: Attribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            chargingPreferences: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    nextChargeTargetSoC: Attribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            chargingPreferences: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    nextChargeTargetTime: Attribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            chargingPreferences: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    randomizationDelayWindow: OptionalWritableAttribute<number, any>;
    sessionDuration: Attribute<null | number, any>;
    sessionEnergyCharged: Attribute<null | number | bigint, any>;
    sessionEnergyDischarged: Attribute<null | number | bigint, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            v2X: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    sessionId: Attribute<null | number, any>;
    state: Attribute<null | EnergyEvse.State, any>;
    stateOfCharge: Attribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            soCReporting: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    supplyState: Attribute<EnergyEvse.SupplyState, any>;
    userMaximumChargeCurrent: OptionalWritableAttribute<number | bigint, any>;
    vehicleId: Attribute<null | string, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            plugAndCharge: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
}, GlobalAttributes<{
    chargingPreferences: BitFlag;
    plugAndCharge: BitFlag;
    rfid: BitFlag;
    soCReporting: BitFlag;
    v2X: BitFlag;
}>>

base

base: undefined

commands

commands: {
    clearTargets: Command<void, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            chargingPreferences: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    disable: Command<void, void, any>;
    enableCharging: Command<TypeFromFields<{
        chargingEnabledUntil: FieldType<null | number>;
        maximumChargeCurrent: FieldType<number | bigint>;
        minimumChargeCurrent: FieldType<number | bigint>;
    }>, void, any>;
    enableDischarging: Command<TypeFromFields<{
        dischargingEnabledUntil: FieldType<null | number>;
        maximumDischargeCurrent: FieldType<number | bigint>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            v2X: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    getTargets: Command<void, TypeFromFields<{
        chargingTargetSchedules: FieldType<TypeFromFields<{
            chargingTargets: OptionalFieldType<(...)[]>;
            dayOfWeekForSequence: OptionalFieldType<TypeFromPartialBitSchema<(...)>>;
        }>[]>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            chargingPreferences: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    setTargets: Command<TypeFromFields<{
        chargingTargetSchedules: FieldType<TypeFromFields<{
            chargingTargets: OptionalFieldType<(...)[]>;
            dayOfWeekForSequence: OptionalFieldType<TypeFromPartialBitSchema<(...)>>;
        }>[]>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            chargingPreferences: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    startDiagnostics: OptionalCommand<void, void, any>;
}

Type declaration

  • ReadonlyclearTargets: Command<void, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            chargingPreferences: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • Readonlydisable: Command<void, void, any>

    Allows a client to disable the EVSE from charging and discharging.

    See

    MatterSpecification.v13.Cluster § 9.3.9.1

  • ReadonlyenableCharging: Command<TypeFromFields<{
        chargingEnabledUntil: FieldType<null | number>;
        maximumChargeCurrent: FieldType<number | bigint>;
        minimumChargeCurrent: FieldType<number | bigint>;
    }>, void, any>

    Allows a client to enable the EVSE to charge an EV.

    See

    MatterSpecification.v13.Cluster § 9.3.9.2

  • ReadonlyenableDischarging: Command<TypeFromFields<{
        dischargingEnabledUntil: FieldType<null | number>;
        maximumDischargeCurrent: FieldType<number | bigint>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            v2X: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlygetTargets: Command<void, TypeFromFields<{
        chargingTargetSchedules: FieldType<TypeFromFields<{
            chargingTargets: OptionalFieldType<(...)[]>;
            dayOfWeekForSequence: OptionalFieldType<TypeFromPartialBitSchema<(...)>>;
        }>[]>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            chargingPreferences: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlysetTargets: Command<TypeFromFields<{
        chargingTargetSchedules: FieldType<TypeFromFields<{
            chargingTargets: OptionalFieldType<(...)[]>;
            dayOfWeekForSequence: OptionalFieldType<TypeFromPartialBitSchema<(...)>>;
        }>[]>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            chargingPreferences: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlystartDiagnostics: OptionalCommand<void, void, any>

    Allows a client to put the EVSE into a self-diagnostics mode.

    See

    MatterSpecification.v13.Cluster § 9.3.9.4

events

events: {
    energyTransferStarted: Event<TypeFromFields<{
        maximumCurrent: FieldType<number | bigint>;
        sessionId: FieldType<number>;
        state: FieldType<EnergyEvse.State>;
    }>, any>;
    energyTransferStopped: Event<TypeFromFields<{
        energyTransferred: FieldType<number | bigint>;
        reason: FieldType<EnergyEvse.EnergyTransferStoppedReason>;
        sessionId: FieldType<number>;
        state: FieldType<EnergyEvse.State>;
    }>, any>;
    evConnected: Event<TypeFromFields<{
        sessionId: FieldType<number>;
    }>, any>;
    evNotDetected: Event<TypeFromFields<{
        sessionDuration: FieldType<number>;
        sessionEnergyCharged: FieldType<number | bigint>;
        sessionEnergyDischarged: OptionalFieldType<number | bigint>;
        sessionId: FieldType<number>;
        state: FieldType<EnergyEvse.State>;
    }>, any>;
    fault: Event<TypeFromFields<{
        faultStateCurrentState: FieldType<EnergyEvse.FaultState>;
        faultStatePreviousState: FieldType<EnergyEvse.FaultState>;
        sessionId: FieldType<null | number>;
        state: FieldType<EnergyEvse.State>;
    }>, any>;
    rfid: OptionalEvent<TypeFromFields<{
        uid: FieldType<Uint8Array>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            rfid: boolean;
        }];
    };
}

Type declaration

  • ReadonlyenergyTransferStarted: Event<TypeFromFields<{
        maximumCurrent: FieldType<number | bigint>;
        sessionId: FieldType<number>;
        state: FieldType<EnergyEvse.State>;
    }>, any>

    This event shall be generated when the EV starts charging or discharging.

    See

    MatterSpecification.v13.Cluster § 9.3.10.3

  • ReadonlyenergyTransferStopped: Event<TypeFromFields<{
        energyTransferred: FieldType<number | bigint>;
        reason: FieldType<EnergyEvse.EnergyTransferStoppedReason>;
        sessionId: FieldType<number>;
        state: FieldType<EnergyEvse.State>;
    }>, any>

    This event shall be generated when the EV stops charging or discharging.

    See

    MatterSpecification.v13.Cluster § 9.3.10.4

  • ReadonlyevConnected: Event<TypeFromFields<{
        sessionId: FieldType<number>;
    }>, any>

    This event shall be generated when the EV is plugged in.

    See

    MatterSpecification.v13.Cluster § 9.3.10.1

  • ReadonlyevNotDetected: Event<TypeFromFields<{
        sessionDuration: FieldType<number>;
        sessionEnergyCharged: FieldType<number | bigint>;
        sessionEnergyDischarged: OptionalFieldType<number | bigint>;
        sessionId: FieldType<number>;
        state: FieldType<EnergyEvse.State>;
    }>, any>

    This event shall be generated when the EV is unplugged or not detected (having been previously plugged in). When the vehicle is unplugged then the session is ended.

    See

    MatterSpecification.v13.Cluster § 9.3.10.2

  • Readonlyfault: Event<TypeFromFields<{
        faultStateCurrentState: FieldType<EnergyEvse.FaultState>;
        faultStatePreviousState: FieldType<EnergyEvse.FaultState>;
        sessionId: FieldType<null | number>;
        state: FieldType<EnergyEvse.State>;
    }>, any>

    If the EVSE detects a fault it shall generate a Fault Event. The SupplyState attribute shall be set to DisabledError and the type of fault detected by the EVSE shall be stored in the FaultState attribute.

    This event shall be generated when the FaultState changes from any error state. i.e. if it changes from NoError to any other state and if the error then clears, this would generate 2 events.

    It is assumed that the fault will be cleared locally on the EVSE device. When all faults have been cleared, the EVSE device shall set the FaultState attribute to NoError and the SupplyState attribute shall be set back to its previous state.

    See

    MatterSpecification.v13.Cluster § 9.3.10.5

  • Readonlyrfid: OptionalEvent<TypeFromFields<{
        uid: FieldType<Uint8Array>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            rfid: boolean;
        }];
    }

extensions

extensions: undefined

features

features: {
    chargingPreferences: BitFlag;
    plugAndCharge: BitFlag;
    rfid: BitFlag;
    soCReporting: BitFlag;
    v2X: BitFlag;
}

Type declaration

  • ReadonlychargingPreferences: BitFlag

    ChargingPreferences

    Since some EVSEs cannot obtain the SoC from the vehicle, some EV charging solutions allow the consumer to specify a daily charging target (for adding energy to the EV’s battery). This feature allows the consumer to specify how many miles or km of additional range they need for their typical daily commute. This range requirement can be converted into a daily energy demand with a target charging completion time.

    The EVSE itself may use this information (or may allow a controller such as an EMS) to compute an

    optimized charging schedule.

    An EVSE device may implement the Device Energy Management cluster PFR (Power Forecast Reporting) and FA (Forecast Adjustment) features. This can help a controller (such as an EMS) to optimize the EVSE against other ESAs. For example, a solar PV ESA may share its Forecast and allow the EVSE to know the best time to charge so that any excess solar generation is used to charge the EV.

    EVSE devices that support the Device Energy Management cluster’s FA feature can have their charging profiles set by a controller device such as an EMS. For example, if the EVSE advertises a simple power forecast which allows the EMS to adjust over a wide range of power and time durations, then the EVSE may allow the EMS to propose a revised optimized forecast (which is the charging profile).

    See the Device Energy Management Cluster for more details.

    See

    MatterSpecification.v13.Cluster § 9.3.4.1

  • ReadonlyplugAndCharge: BitFlag

    PlugAndCharge

    If the EVSE supports PLC, it may be able to support the Plug and Charge feature. e.g. this may allow the vehicle ID to be obtained which may allow an energy management system to track energy usage per vehicle (e.g. to give the owner an indicative cost of charging, or for work place charging).

    If the EVSE supports the Plug and Charge feature, it will only work if a compatible EV is connected.

    See

    MatterSpecification.v13.Cluster § 9.3.4.3

  • Readonlyrfid: BitFlag

    Rfid

    If the EVSE is fitted with an RFID reader, it may be possible to obtain the User or Vehicle ID from an RFID card. This may be used to record a charging session against a specific charging account, and may optionally be used to authorize a charging session.

    An RFID event can be generated when a user taps an RFID card onto the RFID reader. The event must be subscribed to by the EVSE Management cluster client. This client may use this to enable the EV to charge or discharge. The lookup and authorization of RIFD UID is outside the scope of this cluster.

    See

    MatterSpecification.v13.Cluster § 9.3.4.4

  • ReadonlysoCReporting: BitFlag

    SoCReporting

    Vehicles and EVSEs which support ISO 15118 may allow the vehicle to report its battery size and state of charge. If the EVSE supports PLC it may have a vehicle connected which optionally supports reporting of its battery size and current State of Charge (SoC).

    If the EVSE supports reporting of State of Charge this feature will only work if a compatible EV is connected.

    Note some EVSEs may use other undefined mechanisms to obtain vehicle State of Charge outside the scope of this cluster.

    See

    MatterSpecification.v13.Cluster § 9.3.4.2

  • Readonlyv2X: BitFlag

    V2X

    If the EVSE can support bi-directional charging, it may be possible to request that the vehicle can discharge to the home or grid.

    See

    MatterSpecification.v13.Cluster § 9.3.4.5

id

id: Branded<Branded<153, "ClusterId">, "ClusterId">

name

name

revision

revision

supportedFeatures

supportedFeatures: {}

unknown

unknown

Methods

alter

  • alter<const AlterationsT>(alterations): WithAlterations<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            approximateEvEfficiency: OptionalWritableAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    chargingPreferences: boolean;
                }];
            };
            attributeList: Attribute<AttributeId[], never>;
            batteryCapacity: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    soCReporting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            chargingEnabledUntil: Attribute<null | number, any>;
            circuitCapacity: Attribute<number | bigint, any>;
            clusterRevision: Attribute<number, never>;
            dischargingEnabledUntil: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    v2X: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            faultState: Attribute<EnergyEvse.FaultState, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                chargingPreferences: BitFlag;
                plugAndCharge: BitFlag;
                rfid: BitFlag;
                soCReporting: BitFlag;
                v2X: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maximumChargeCurrent: Attribute<number | bigint, any>;
            maximumDischargeCurrent: Attribute<number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    v2X: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minimumChargeCurrent: Attribute<number | bigint, any>;
            nextChargeRequiredEnergy: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            nextChargeStartTime: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            nextChargeTargetSoC: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            nextChargeTargetTime: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            randomizationDelayWindow: OptionalWritableAttribute<number, any>;
            sessionDuration: Attribute<null | number, any>;
            sessionEnergyCharged: Attribute<null | number | bigint, any>;
            sessionEnergyDischarged: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    v2X: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            sessionId: Attribute<null | number, any>;
            state: Attribute<null | EnergyEvse.State, any>;
            stateOfCharge: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    soCReporting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supplyState: Attribute<EnergyEvse.SupplyState, any>;
            userMaximumChargeCurrent: OptionalWritableAttribute<number | bigint, any>;
            vehicleId: Attribute<null | string, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    plugAndCharge: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            clearTargets: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            disable: Command<void, void, any>;
            enableCharging: Command<TypeFromFields<{
                chargingEnabledUntil: FieldType<null | number>;
                maximumChargeCurrent: FieldType<number | bigint>;
                minimumChargeCurrent: FieldType<number | bigint>;
            }>, void, any>;
            enableDischarging: Command<TypeFromFields<{
                dischargingEnabledUntil: FieldType<null | number>;
                maximumDischargeCurrent: FieldType<number | bigint>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    v2X: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getTargets: Command<void, TypeFromFields<{
                chargingTargetSchedules: FieldType<TypeFromFields<(...)>[]>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setTargets: Command<TypeFromFields<{
                chargingTargetSchedules: FieldType<TypeFromFields<(...)>[]>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            startDiagnostics: OptionalCommand<void, void, any>;
        };
        events: {
            energyTransferStarted: Event<TypeFromFields<{
                maximumCurrent: FieldType<number | bigint>;
                sessionId: FieldType<number>;
                state: FieldType<EnergyEvse.State>;
            }>, any>;
            energyTransferStopped: Event<TypeFromFields<{
                energyTransferred: FieldType<number | bigint>;
                reason: FieldType<EnergyEvse.EnergyTransferStoppedReason>;
                sessionId: FieldType<number>;
                state: FieldType<EnergyEvse.State>;
            }>, any>;
            evConnected: Event<TypeFromFields<{
                sessionId: FieldType<number>;
            }>, any>;
            evNotDetected: Event<TypeFromFields<{
                sessionDuration: FieldType<number>;
                sessionEnergyCharged: FieldType<number | bigint>;
                sessionEnergyDischarged: OptionalFieldType<number | bigint>;
                sessionId: FieldType<number>;
                state: FieldType<EnergyEvse.State>;
            }>, any>;
            fault: Event<TypeFromFields<{
                faultStateCurrentState: FieldType<EnergyEvse.FaultState>;
                faultStatePreviousState: FieldType<EnergyEvse.FaultState>;
                sessionId: FieldType<null | number>;
                state: FieldType<EnergyEvse.State>;
            }>, any>;
            rfid: OptionalEvent<TypeFromFields<{
                uid: FieldType<Uint8Array>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    rfid: boolean;
                }];
            };
        };
        features: {
            chargingPreferences: BitFlag;
            plugAndCharge: BitFlag;
            rfid: BitFlag;
            soCReporting: BitFlag;
            v2X: BitFlag;
        };
        id: Branded<153, "ClusterId">;
        name: "EnergyEvse";
        revision: 2;
    }>, AlterationsT>

  • Modify elements using ElementModifier.alter.

    Type Parameters

    • const AlterationsT extends Alterations<Of<{
          attributes: {
              acceptedCommandList: Attribute<CommandId[], never>;
              approximateEvEfficiency: OptionalWritableAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      chargingPreferences: boolean;
                  }];
              };
              attributeList: Attribute<AttributeId[], never>;
              batteryCapacity: Attribute<null | number | bigint, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      soCReporting: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              chargingEnabledUntil: Attribute<null | number, any>;
              circuitCapacity: Attribute<number | bigint, any>;
              clusterRevision: Attribute<number, never>;
              dischargingEnabledUntil: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      v2X: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              faultState: Attribute<EnergyEvse.FaultState, any>;
              featureMap: Attribute<TypeFromPartialBitSchema<{
                  chargingPreferences: BitFlag;
                  plugAndCharge: BitFlag;
                  rfid: BitFlag;
                  soCReporting: BitFlag;
                  v2X: BitFlag;
              }>, never>;
              generatedCommandList: Attribute<CommandId[], never>;
              maximumChargeCurrent: Attribute<number | bigint, any>;
              maximumDischargeCurrent: Attribute<number | bigint, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      v2X: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              minimumChargeCurrent: Attribute<number | bigint, any>;
              nextChargeRequiredEnergy: Attribute<null | number | bigint, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      chargingPreferences: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              nextChargeStartTime: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      chargingPreferences: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              nextChargeTargetSoC: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      chargingPreferences: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              nextChargeTargetTime: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      chargingPreferences: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              randomizationDelayWindow: OptionalWritableAttribute<number, any>;
              sessionDuration: Attribute<null | number, any>;
              sessionEnergyCharged: Attribute<null | number | bigint, any>;
              sessionEnergyDischarged: Attribute<null | number | bigint, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      v2X: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              sessionId: Attribute<null | number, any>;
              state: Attribute<null | EnergyEvse.State, any>;
              stateOfCharge: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      soCReporting: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              supplyState: Attribute<EnergyEvse.SupplyState, any>;
              userMaximumChargeCurrent: OptionalWritableAttribute<number | bigint, any>;
              vehicleId: Attribute<null | string, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      plugAndCharge: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          commands: {
              clearTargets: Command<void, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      chargingPreferences: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              disable: Command<void, void, any>;
              enableCharging: Command<TypeFromFields<{
                  chargingEnabledUntil: FieldType<null | number>;
                  maximumChargeCurrent: FieldType<number | bigint>;
                  minimumChargeCurrent: FieldType<number | bigint>;
              }>, void, any>;
              enableDischarging: Command<TypeFromFields<{
                  dischargingEnabledUntil: FieldType<null | number>;
                  maximumDischargeCurrent: FieldType<number | bigint>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      v2X: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              getTargets: Command<void, TypeFromFields<{
                  chargingTargetSchedules: FieldType<TypeFromFields<(...)>[]>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      chargingPreferences: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              setTargets: Command<TypeFromFields<{
                  chargingTargetSchedules: FieldType<TypeFromFields<(...)>[]>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      chargingPreferences: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              startDiagnostics: OptionalCommand<void, void, any>;
          };
          events: {
              energyTransferStarted: Event<TypeFromFields<{
                  maximumCurrent: FieldType<number | bigint>;
                  sessionId: FieldType<number>;
                  state: FieldType<EnergyEvse.State>;
              }>, any>;
              energyTransferStopped: Event<TypeFromFields<{
                  energyTransferred: FieldType<number | bigint>;
                  reason: FieldType<EnergyEvse.EnergyTransferStoppedReason>;
                  sessionId: FieldType<number>;
                  state: FieldType<EnergyEvse.State>;
              }>, any>;
              evConnected: Event<TypeFromFields<{
                  sessionId: FieldType<number>;
              }>, any>;
              evNotDetected: Event<TypeFromFields<{
                  sessionDuration: FieldType<number>;
                  sessionEnergyCharged: FieldType<number | bigint>;
                  sessionEnergyDischarged: OptionalFieldType<number | bigint>;
                  sessionId: FieldType<number>;
                  state: FieldType<EnergyEvse.State>;
              }>, any>;
              fault: Event<TypeFromFields<{
                  faultStateCurrentState: FieldType<EnergyEvse.FaultState>;
                  faultStatePreviousState: FieldType<EnergyEvse.FaultState>;
                  sessionId: FieldType<null | number>;
                  state: FieldType<EnergyEvse.State>;
              }>, any>;
              rfid: OptionalEvent<TypeFromFields<{
                  uid: FieldType<Uint8Array>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      rfid: boolean;
                  }];
              };
          };
          features: {
              chargingPreferences: BitFlag;
              plugAndCharge: BitFlag;
              rfid: BitFlag;
              soCReporting: BitFlag;
              v2X: BitFlag;
          };
          id: Branded<153, "ClusterId">;
          name: "EnergyEvse";
          revision: 2;
      }>>

    Parameters

    Returns WithAlterations<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            approximateEvEfficiency: OptionalWritableAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    chargingPreferences: boolean;
                }];
            };
            attributeList: Attribute<AttributeId[], never>;
            batteryCapacity: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    soCReporting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            chargingEnabledUntil: Attribute<null | number, any>;
            circuitCapacity: Attribute<number | bigint, any>;
            clusterRevision: Attribute<number, never>;
            dischargingEnabledUntil: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    v2X: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            faultState: Attribute<EnergyEvse.FaultState, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                chargingPreferences: BitFlag;
                plugAndCharge: BitFlag;
                rfid: BitFlag;
                soCReporting: BitFlag;
                v2X: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maximumChargeCurrent: Attribute<number | bigint, any>;
            maximumDischargeCurrent: Attribute<number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    v2X: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minimumChargeCurrent: Attribute<number | bigint, any>;
            nextChargeRequiredEnergy: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            nextChargeStartTime: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            nextChargeTargetSoC: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            nextChargeTargetTime: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            randomizationDelayWindow: OptionalWritableAttribute<number, any>;
            sessionDuration: Attribute<null | number, any>;
            sessionEnergyCharged: Attribute<null | number | bigint, any>;
            sessionEnergyDischarged: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    v2X: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            sessionId: Attribute<null | number, any>;
            state: Attribute<null | EnergyEvse.State, any>;
            stateOfCharge: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    soCReporting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supplyState: Attribute<EnergyEvse.SupplyState, any>;
            userMaximumChargeCurrent: OptionalWritableAttribute<number | bigint, any>;
            vehicleId: Attribute<null | string, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    plugAndCharge: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            clearTargets: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            disable: Command<void, void, any>;
            enableCharging: Command<TypeFromFields<{
                chargingEnabledUntil: FieldType<null | number>;
                maximumChargeCurrent: FieldType<number | bigint>;
                minimumChargeCurrent: FieldType<number | bigint>;
            }>, void, any>;
            enableDischarging: Command<TypeFromFields<{
                dischargingEnabledUntil: FieldType<null | number>;
                maximumDischargeCurrent: FieldType<number | bigint>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    v2X: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getTargets: Command<void, TypeFromFields<{
                chargingTargetSchedules: FieldType<TypeFromFields<(...)>[]>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setTargets: Command<TypeFromFields<{
                chargingTargetSchedules: FieldType<TypeFromFields<(...)>[]>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            startDiagnostics: OptionalCommand<void, void, any>;
        };
        events: {
            energyTransferStarted: Event<TypeFromFields<{
                maximumCurrent: FieldType<number | bigint>;
                sessionId: FieldType<number>;
                state: FieldType<EnergyEvse.State>;
            }>, any>;
            energyTransferStopped: Event<TypeFromFields<{
                energyTransferred: FieldType<number | bigint>;
                reason: FieldType<EnergyEvse.EnergyTransferStoppedReason>;
                sessionId: FieldType<number>;
                state: FieldType<EnergyEvse.State>;
            }>, any>;
            evConnected: Event<TypeFromFields<{
                sessionId: FieldType<number>;
            }>, any>;
            evNotDetected: Event<TypeFromFields<{
                sessionDuration: FieldType<number>;
                sessionEnergyCharged: FieldType<number | bigint>;
                sessionEnergyDischarged: OptionalFieldType<number | bigint>;
                sessionId: FieldType<number>;
                state: FieldType<EnergyEvse.State>;
            }>, any>;
            fault: Event<TypeFromFields<{
                faultStateCurrentState: FieldType<EnergyEvse.FaultState>;
                faultStatePreviousState: FieldType<EnergyEvse.FaultState>;
                sessionId: FieldType<null | number>;
                state: FieldType<EnergyEvse.State>;
            }>, any>;
            rfid: OptionalEvent<TypeFromFields<{
                uid: FieldType<Uint8Array>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    rfid: boolean;
                }];
            };
        };
        features: {
            chargingPreferences: BitFlag;
            plugAndCharge: BitFlag;
            rfid: BitFlag;
            soCReporting: BitFlag;
            v2X: BitFlag;
        };
        id: Branded<153, "ClusterId">;
        name: "EnergyEvse";
        revision: 2;
    }>, AlterationsT>

enable

  • enable<const FlagsT>(flags): WithFlags<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            approximateEvEfficiency: OptionalWritableAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    chargingPreferences: boolean;
                }];
            };
            attributeList: Attribute<AttributeId[], never>;
            batteryCapacity: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    soCReporting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            chargingEnabledUntil: Attribute<null | number, any>;
            circuitCapacity: Attribute<number | bigint, any>;
            clusterRevision: Attribute<number, never>;
            dischargingEnabledUntil: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    v2X: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            faultState: Attribute<EnergyEvse.FaultState, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                chargingPreferences: BitFlag;
                plugAndCharge: BitFlag;
                rfid: BitFlag;
                soCReporting: BitFlag;
                v2X: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maximumChargeCurrent: Attribute<number | bigint, any>;
            maximumDischargeCurrent: Attribute<number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    v2X: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minimumChargeCurrent: Attribute<number | bigint, any>;
            nextChargeRequiredEnergy: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            nextChargeStartTime: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            nextChargeTargetSoC: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            nextChargeTargetTime: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            randomizationDelayWindow: OptionalWritableAttribute<number, any>;
            sessionDuration: Attribute<null | number, any>;
            sessionEnergyCharged: Attribute<null | number | bigint, any>;
            sessionEnergyDischarged: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    v2X: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            sessionId: Attribute<null | number, any>;
            state: Attribute<null | EnergyEvse.State, any>;
            stateOfCharge: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    soCReporting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supplyState: Attribute<EnergyEvse.SupplyState, any>;
            userMaximumChargeCurrent: OptionalWritableAttribute<number | bigint, any>;
            vehicleId: Attribute<null | string, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    plugAndCharge: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            clearTargets: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            disable: Command<void, void, any>;
            enableCharging: Command<TypeFromFields<{
                chargingEnabledUntil: FieldType<null | number>;
                maximumChargeCurrent: FieldType<number | bigint>;
                minimumChargeCurrent: FieldType<number | bigint>;
            }>, void, any>;
            enableDischarging: Command<TypeFromFields<{
                dischargingEnabledUntil: FieldType<null | number>;
                maximumDischargeCurrent: FieldType<number | bigint>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    v2X: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getTargets: Command<void, TypeFromFields<{
                chargingTargetSchedules: FieldType<TypeFromFields<(...)>[]>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setTargets: Command<TypeFromFields<{
                chargingTargetSchedules: FieldType<TypeFromFields<(...)>[]>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            startDiagnostics: OptionalCommand<void, void, any>;
        };
        events: {
            energyTransferStarted: Event<TypeFromFields<{
                maximumCurrent: FieldType<number | bigint>;
                sessionId: FieldType<number>;
                state: FieldType<EnergyEvse.State>;
            }>, any>;
            energyTransferStopped: Event<TypeFromFields<{
                energyTransferred: FieldType<number | bigint>;
                reason: FieldType<EnergyEvse.EnergyTransferStoppedReason>;
                sessionId: FieldType<number>;
                state: FieldType<EnergyEvse.State>;
            }>, any>;
            evConnected: Event<TypeFromFields<{
                sessionId: FieldType<number>;
            }>, any>;
            evNotDetected: Event<TypeFromFields<{
                sessionDuration: FieldType<number>;
                sessionEnergyCharged: FieldType<number | bigint>;
                sessionEnergyDischarged: OptionalFieldType<number | bigint>;
                sessionId: FieldType<number>;
                state: FieldType<EnergyEvse.State>;
            }>, any>;
            fault: Event<TypeFromFields<{
                faultStateCurrentState: FieldType<EnergyEvse.FaultState>;
                faultStatePreviousState: FieldType<EnergyEvse.FaultState>;
                sessionId: FieldType<null | number>;
                state: FieldType<EnergyEvse.State>;
            }>, any>;
            rfid: OptionalEvent<TypeFromFields<{
                uid: FieldType<Uint8Array>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    rfid: boolean;
                }];
            };
        };
        features: {
            chargingPreferences: BitFlag;
            plugAndCharge: BitFlag;
            rfid: BitFlag;
            soCReporting: BitFlag;
            v2X: BitFlag;
        };
        id: Branded<153, "ClusterId">;
        name: "EnergyEvse";
        revision: 2;
    }>, FlagsT>

  • Modify elements using ElementModifier.enable.

    Type Parameters

    • const FlagsT extends ElementFlags<Of<{
          attributes: {
              acceptedCommandList: Attribute<CommandId[], never>;
              approximateEvEfficiency: OptionalWritableAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      chargingPreferences: boolean;
                  }];
              };
              attributeList: Attribute<AttributeId[], never>;
              batteryCapacity: Attribute<null | number | bigint, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      soCReporting: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              chargingEnabledUntil: Attribute<null | number, any>;
              circuitCapacity: Attribute<number | bigint, any>;
              clusterRevision: Attribute<number, never>;
              dischargingEnabledUntil: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      v2X: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              faultState: Attribute<EnergyEvse.FaultState, any>;
              featureMap: Attribute<TypeFromPartialBitSchema<{
                  chargingPreferences: BitFlag;
                  plugAndCharge: BitFlag;
                  rfid: BitFlag;
                  soCReporting: BitFlag;
                  v2X: BitFlag;
              }>, never>;
              generatedCommandList: Attribute<CommandId[], never>;
              maximumChargeCurrent: Attribute<number | bigint, any>;
              maximumDischargeCurrent: Attribute<number | bigint, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      v2X: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              minimumChargeCurrent: Attribute<number | bigint, any>;
              nextChargeRequiredEnergy: Attribute<null | number | bigint, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      chargingPreferences: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              nextChargeStartTime: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      chargingPreferences: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              nextChargeTargetSoC: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      chargingPreferences: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              nextChargeTargetTime: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      chargingPreferences: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              randomizationDelayWindow: OptionalWritableAttribute<number, any>;
              sessionDuration: Attribute<null | number, any>;
              sessionEnergyCharged: Attribute<null | number | bigint, any>;
              sessionEnergyDischarged: Attribute<null | number | bigint, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      v2X: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              sessionId: Attribute<null | number, any>;
              state: Attribute<null | EnergyEvse.State, any>;
              stateOfCharge: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      soCReporting: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              supplyState: Attribute<EnergyEvse.SupplyState, any>;
              userMaximumChargeCurrent: OptionalWritableAttribute<number | bigint, any>;
              vehicleId: Attribute<null | string, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      plugAndCharge: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          commands: {
              clearTargets: Command<void, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      chargingPreferences: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              disable: Command<void, void, any>;
              enableCharging: Command<TypeFromFields<{
                  chargingEnabledUntil: FieldType<null | number>;
                  maximumChargeCurrent: FieldType<number | bigint>;
                  minimumChargeCurrent: FieldType<number | bigint>;
              }>, void, any>;
              enableDischarging: Command<TypeFromFields<{
                  dischargingEnabledUntil: FieldType<null | number>;
                  maximumDischargeCurrent: FieldType<number | bigint>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      v2X: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              getTargets: Command<void, TypeFromFields<{
                  chargingTargetSchedules: FieldType<TypeFromFields<(...)>[]>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      chargingPreferences: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              setTargets: Command<TypeFromFields<{
                  chargingTargetSchedules: FieldType<TypeFromFields<(...)>[]>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      chargingPreferences: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              startDiagnostics: OptionalCommand<void, void, any>;
          };
          events: {
              energyTransferStarted: Event<TypeFromFields<{
                  maximumCurrent: FieldType<number | bigint>;
                  sessionId: FieldType<number>;
                  state: FieldType<EnergyEvse.State>;
              }>, any>;
              energyTransferStopped: Event<TypeFromFields<{
                  energyTransferred: FieldType<number | bigint>;
                  reason: FieldType<EnergyEvse.EnergyTransferStoppedReason>;
                  sessionId: FieldType<number>;
                  state: FieldType<EnergyEvse.State>;
              }>, any>;
              evConnected: Event<TypeFromFields<{
                  sessionId: FieldType<number>;
              }>, any>;
              evNotDetected: Event<TypeFromFields<{
                  sessionDuration: FieldType<number>;
                  sessionEnergyCharged: FieldType<number | bigint>;
                  sessionEnergyDischarged: OptionalFieldType<number | bigint>;
                  sessionId: FieldType<number>;
                  state: FieldType<EnergyEvse.State>;
              }>, any>;
              fault: Event<TypeFromFields<{
                  faultStateCurrentState: FieldType<EnergyEvse.FaultState>;
                  faultStatePreviousState: FieldType<EnergyEvse.FaultState>;
                  sessionId: FieldType<null | number>;
                  state: FieldType<EnergyEvse.State>;
              }>, any>;
              rfid: OptionalEvent<TypeFromFields<{
                  uid: FieldType<Uint8Array>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      rfid: boolean;
                  }];
              };
          };
          features: {
              chargingPreferences: BitFlag;
              plugAndCharge: BitFlag;
              rfid: BitFlag;
              soCReporting: BitFlag;
              v2X: BitFlag;
          };
          id: Branded<153, "ClusterId">;
          name: "EnergyEvse";
          revision: 2;
      }>>

    Parameters

    Returns WithFlags<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            approximateEvEfficiency: OptionalWritableAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    chargingPreferences: boolean;
                }];
            };
            attributeList: Attribute<AttributeId[], never>;
            batteryCapacity: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    soCReporting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            chargingEnabledUntil: Attribute<null | number, any>;
            circuitCapacity: Attribute<number | bigint, any>;
            clusterRevision: Attribute<number, never>;
            dischargingEnabledUntil: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    v2X: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            faultState: Attribute<EnergyEvse.FaultState, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                chargingPreferences: BitFlag;
                plugAndCharge: BitFlag;
                rfid: BitFlag;
                soCReporting: BitFlag;
                v2X: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maximumChargeCurrent: Attribute<number | bigint, any>;
            maximumDischargeCurrent: Attribute<number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    v2X: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minimumChargeCurrent: Attribute<number | bigint, any>;
            nextChargeRequiredEnergy: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            nextChargeStartTime: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            nextChargeTargetSoC: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            nextChargeTargetTime: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            randomizationDelayWindow: OptionalWritableAttribute<number, any>;
            sessionDuration: Attribute<null | number, any>;
            sessionEnergyCharged: Attribute<null | number | bigint, any>;
            sessionEnergyDischarged: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    v2X: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            sessionId: Attribute<null | number, any>;
            state: Attribute<null | EnergyEvse.State, any>;
            stateOfCharge: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    soCReporting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supplyState: Attribute<EnergyEvse.SupplyState, any>;
            userMaximumChargeCurrent: OptionalWritableAttribute<number | bigint, any>;
            vehicleId: Attribute<null | string, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    plugAndCharge: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            clearTargets: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            disable: Command<void, void, any>;
            enableCharging: Command<TypeFromFields<{
                chargingEnabledUntil: FieldType<null | number>;
                maximumChargeCurrent: FieldType<number | bigint>;
                minimumChargeCurrent: FieldType<number | bigint>;
            }>, void, any>;
            enableDischarging: Command<TypeFromFields<{
                dischargingEnabledUntil: FieldType<null | number>;
                maximumDischargeCurrent: FieldType<number | bigint>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    v2X: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getTargets: Command<void, TypeFromFields<{
                chargingTargetSchedules: FieldType<TypeFromFields<(...)>[]>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setTargets: Command<TypeFromFields<{
                chargingTargetSchedules: FieldType<TypeFromFields<(...)>[]>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            startDiagnostics: OptionalCommand<void, void, any>;
        };
        events: {
            energyTransferStarted: Event<TypeFromFields<{
                maximumCurrent: FieldType<number | bigint>;
                sessionId: FieldType<number>;
                state: FieldType<EnergyEvse.State>;
            }>, any>;
            energyTransferStopped: Event<TypeFromFields<{
                energyTransferred: FieldType<number | bigint>;
                reason: FieldType<EnergyEvse.EnergyTransferStoppedReason>;
                sessionId: FieldType<number>;
                state: FieldType<EnergyEvse.State>;
            }>, any>;
            evConnected: Event<TypeFromFields<{
                sessionId: FieldType<number>;
            }>, any>;
            evNotDetected: Event<TypeFromFields<{
                sessionDuration: FieldType<number>;
                sessionEnergyCharged: FieldType<number | bigint>;
                sessionEnergyDischarged: OptionalFieldType<number | bigint>;
                sessionId: FieldType<number>;
                state: FieldType<EnergyEvse.State>;
            }>, any>;
            fault: Event<TypeFromFields<{
                faultStateCurrentState: FieldType<EnergyEvse.FaultState>;
                faultStatePreviousState: FieldType<EnergyEvse.FaultState>;
                sessionId: FieldType<null | number>;
                state: FieldType<EnergyEvse.State>;
            }>, any>;
            rfid: OptionalEvent<TypeFromFields<{
                uid: FieldType<Uint8Array>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    rfid: boolean;
                }];
            };
        };
        features: {
            chargingPreferences: BitFlag;
            plugAndCharge: BitFlag;
            rfid: BitFlag;
            soCReporting: BitFlag;
            v2X: BitFlag;
        };
        id: Branded<153, "ClusterId">;
        name: "EnergyEvse";
        revision: 2;
    }>, FlagsT>

set

  • set<const ValuesT>(values): WithValues<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            approximateEvEfficiency: OptionalWritableAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    chargingPreferences: boolean;
                }];
            };
            attributeList: Attribute<AttributeId[], never>;
            batteryCapacity: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    soCReporting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            chargingEnabledUntil: Attribute<null | number, any>;
            circuitCapacity: Attribute<number | bigint, any>;
            clusterRevision: Attribute<number, never>;
            dischargingEnabledUntil: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    v2X: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            faultState: Attribute<EnergyEvse.FaultState, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                chargingPreferences: BitFlag;
                plugAndCharge: BitFlag;
                rfid: BitFlag;
                soCReporting: BitFlag;
                v2X: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maximumChargeCurrent: Attribute<number | bigint, any>;
            maximumDischargeCurrent: Attribute<number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    v2X: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minimumChargeCurrent: Attribute<number | bigint, any>;
            nextChargeRequiredEnergy: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            nextChargeStartTime: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            nextChargeTargetSoC: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            nextChargeTargetTime: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            randomizationDelayWindow: OptionalWritableAttribute<number, any>;
            sessionDuration: Attribute<null | number, any>;
            sessionEnergyCharged: Attribute<null | number | bigint, any>;
            sessionEnergyDischarged: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    v2X: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            sessionId: Attribute<null | number, any>;
            state: Attribute<null | EnergyEvse.State, any>;
            stateOfCharge: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    soCReporting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supplyState: Attribute<EnergyEvse.SupplyState, any>;
            userMaximumChargeCurrent: OptionalWritableAttribute<number | bigint, any>;
            vehicleId: Attribute<null | string, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    plugAndCharge: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            clearTargets: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            disable: Command<void, void, any>;
            enableCharging: Command<TypeFromFields<{
                chargingEnabledUntil: FieldType<null | number>;
                maximumChargeCurrent: FieldType<number | bigint>;
                minimumChargeCurrent: FieldType<number | bigint>;
            }>, void, any>;
            enableDischarging: Command<TypeFromFields<{
                dischargingEnabledUntil: FieldType<null | number>;
                maximumDischargeCurrent: FieldType<number | bigint>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    v2X: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getTargets: Command<void, TypeFromFields<{
                chargingTargetSchedules: FieldType<TypeFromFields<(...)>[]>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setTargets: Command<TypeFromFields<{
                chargingTargetSchedules: FieldType<TypeFromFields<(...)>[]>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            startDiagnostics: OptionalCommand<void, void, any>;
        };
        events: {
            energyTransferStarted: Event<TypeFromFields<{
                maximumCurrent: FieldType<number | bigint>;
                sessionId: FieldType<number>;
                state: FieldType<EnergyEvse.State>;
            }>, any>;
            energyTransferStopped: Event<TypeFromFields<{
                energyTransferred: FieldType<number | bigint>;
                reason: FieldType<EnergyEvse.EnergyTransferStoppedReason>;
                sessionId: FieldType<number>;
                state: FieldType<EnergyEvse.State>;
            }>, any>;
            evConnected: Event<TypeFromFields<{
                sessionId: FieldType<number>;
            }>, any>;
            evNotDetected: Event<TypeFromFields<{
                sessionDuration: FieldType<number>;
                sessionEnergyCharged: FieldType<number | bigint>;
                sessionEnergyDischarged: OptionalFieldType<number | bigint>;
                sessionId: FieldType<number>;
                state: FieldType<EnergyEvse.State>;
            }>, any>;
            fault: Event<TypeFromFields<{
                faultStateCurrentState: FieldType<EnergyEvse.FaultState>;
                faultStatePreviousState: FieldType<EnergyEvse.FaultState>;
                sessionId: FieldType<null | number>;
                state: FieldType<EnergyEvse.State>;
            }>, any>;
            rfid: OptionalEvent<TypeFromFields<{
                uid: FieldType<Uint8Array>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    rfid: boolean;
                }];
            };
        };
        features: {
            chargingPreferences: BitFlag;
            plugAndCharge: BitFlag;
            rfid: BitFlag;
            soCReporting: BitFlag;
            v2X: BitFlag;
        };
        id: Branded<153, "ClusterId">;
        name: "EnergyEvse";
        revision: 2;
    }>, ValuesT>

  • Modify elements using ElementModifier.set.

    Type Parameters

    • const ValuesT extends {
          approximateEvEfficiency?: null | number;
          batteryCapacity?: null | number | bigint;
          chargingEnabledUntil: null | number;
          circuitCapacity: number | bigint;
          dischargingEnabledUntil?: null | number;
          faultState: number;
          maximumChargeCurrent: number | bigint;
          maximumDischargeCurrent?: number | bigint;
          minimumChargeCurrent: number | bigint;
          nextChargeRequiredEnergy?: null | number | bigint;
          nextChargeStartTime?: null | number;
          nextChargeTargetSoC?: null | number;
          nextChargeTargetTime?: null | number;
          randomizationDelayWindow?: number;
          sessionDuration: null | number;
          sessionEnergyCharged: null | number | bigint;
          sessionEnergyDischarged?: null | number | bigint;
          sessionId: null | number;
          state: null | number;
          stateOfCharge?: null | number;
          supplyState: number;
          userMaximumChargeCurrent?: number | bigint;
          vehicleId?: null | string;
      }

    Parameters

    Returns WithValues<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            approximateEvEfficiency: OptionalWritableAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    chargingPreferences: boolean;
                }];
            };
            attributeList: Attribute<AttributeId[], never>;
            batteryCapacity: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    soCReporting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            chargingEnabledUntil: Attribute<null | number, any>;
            circuitCapacity: Attribute<number | bigint, any>;
            clusterRevision: Attribute<number, never>;
            dischargingEnabledUntil: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    v2X: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            faultState: Attribute<EnergyEvse.FaultState, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                chargingPreferences: BitFlag;
                plugAndCharge: BitFlag;
                rfid: BitFlag;
                soCReporting: BitFlag;
                v2X: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maximumChargeCurrent: Attribute<number | bigint, any>;
            maximumDischargeCurrent: Attribute<number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    v2X: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minimumChargeCurrent: Attribute<number | bigint, any>;
            nextChargeRequiredEnergy: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            nextChargeStartTime: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            nextChargeTargetSoC: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            nextChargeTargetTime: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            randomizationDelayWindow: OptionalWritableAttribute<number, any>;
            sessionDuration: Attribute<null | number, any>;
            sessionEnergyCharged: Attribute<null | number | bigint, any>;
            sessionEnergyDischarged: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    v2X: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            sessionId: Attribute<null | number, any>;
            state: Attribute<null | EnergyEvse.State, any>;
            stateOfCharge: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    soCReporting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supplyState: Attribute<EnergyEvse.SupplyState, any>;
            userMaximumChargeCurrent: OptionalWritableAttribute<number | bigint, any>;
            vehicleId: Attribute<null | string, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    plugAndCharge: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            clearTargets: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            disable: Command<void, void, any>;
            enableCharging: Command<TypeFromFields<{
                chargingEnabledUntil: FieldType<null | number>;
                maximumChargeCurrent: FieldType<number | bigint>;
                minimumChargeCurrent: FieldType<number | bigint>;
            }>, void, any>;
            enableDischarging: Command<TypeFromFields<{
                dischargingEnabledUntil: FieldType<null | number>;
                maximumDischargeCurrent: FieldType<number | bigint>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    v2X: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getTargets: Command<void, TypeFromFields<{
                chargingTargetSchedules: FieldType<TypeFromFields<(...)>[]>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setTargets: Command<TypeFromFields<{
                chargingTargetSchedules: FieldType<TypeFromFields<(...)>[]>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            startDiagnostics: OptionalCommand<void, void, any>;
        };
        events: {
            energyTransferStarted: Event<TypeFromFields<{
                maximumCurrent: FieldType<number | bigint>;
                sessionId: FieldType<number>;
                state: FieldType<EnergyEvse.State>;
            }>, any>;
            energyTransferStopped: Event<TypeFromFields<{
                energyTransferred: FieldType<number | bigint>;
                reason: FieldType<EnergyEvse.EnergyTransferStoppedReason>;
                sessionId: FieldType<number>;
                state: FieldType<EnergyEvse.State>;
            }>, any>;
            evConnected: Event<TypeFromFields<{
                sessionId: FieldType<number>;
            }>, any>;
            evNotDetected: Event<TypeFromFields<{
                sessionDuration: FieldType<number>;
                sessionEnergyCharged: FieldType<number | bigint>;
                sessionEnergyDischarged: OptionalFieldType<number | bigint>;
                sessionId: FieldType<number>;
                state: FieldType<EnergyEvse.State>;
            }>, any>;
            fault: Event<TypeFromFields<{
                faultStateCurrentState: FieldType<EnergyEvse.FaultState>;
                faultStatePreviousState: FieldType<EnergyEvse.FaultState>;
                sessionId: FieldType<null | number>;
                state: FieldType<EnergyEvse.State>;
            }>, any>;
            rfid: OptionalEvent<TypeFromFields<{
                uid: FieldType<Uint8Array>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    rfid: boolean;
                }];
            };
        };
        features: {
            chargingPreferences: BitFlag;
            plugAndCharge: BitFlag;
            rfid: BitFlag;
            soCReporting: BitFlag;
            v2X: BitFlag;
        };
        id: Branded<153, "ClusterId">;
        name: "EnergyEvse";
        revision: 2;
    }>, ValuesT>

with

  • with<const SelectionT>(...selection): Of<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            approximateEvEfficiency: OptionalWritableAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    chargingPreferences: boolean;
                }];
            };
            attributeList: Attribute<AttributeId[], never>;
            batteryCapacity: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    soCReporting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            chargingEnabledUntil: Attribute<null | number, any>;
            circuitCapacity: Attribute<number | bigint, any>;
            clusterRevision: Attribute<number, never>;
            dischargingEnabledUntil: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    v2X: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            faultState: Attribute<EnergyEvse.FaultState, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                chargingPreferences: BitFlag;
                plugAndCharge: BitFlag;
                rfid: BitFlag;
                soCReporting: BitFlag;
                v2X: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maximumChargeCurrent: Attribute<number | bigint, any>;
            maximumDischargeCurrent: Attribute<number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    v2X: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minimumChargeCurrent: Attribute<number | bigint, any>;
            nextChargeRequiredEnergy: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            nextChargeStartTime: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            nextChargeTargetSoC: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            nextChargeTargetTime: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            randomizationDelayWindow: OptionalWritableAttribute<number, any>;
            sessionDuration: Attribute<null | number, any>;
            sessionEnergyCharged: Attribute<null | number | bigint, any>;
            sessionEnergyDischarged: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    v2X: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            sessionId: Attribute<null | number, any>;
            state: Attribute<null | EnergyEvse.State, any>;
            stateOfCharge: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    soCReporting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supplyState: Attribute<EnergyEvse.SupplyState, any>;
            userMaximumChargeCurrent: OptionalWritableAttribute<number | bigint, any>;
            vehicleId: Attribute<null | string, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    plugAndCharge: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            clearTargets: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            disable: Command<void, void, any>;
            enableCharging: Command<TypeFromFields<{
                chargingEnabledUntil: FieldType<null | number>;
                maximumChargeCurrent: FieldType<number | bigint>;
                minimumChargeCurrent: FieldType<number | bigint>;
            }>, void, any>;
            enableDischarging: Command<TypeFromFields<{
                dischargingEnabledUntil: FieldType<null | number>;
                maximumDischargeCurrent: FieldType<number | bigint>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    v2X: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getTargets: Command<void, TypeFromFields<{
                chargingTargetSchedules: FieldType<TypeFromFields<(...)>[]>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setTargets: Command<TypeFromFields<{
                chargingTargetSchedules: FieldType<TypeFromFields<(...)>[]>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            startDiagnostics: OptionalCommand<void, void, any>;
        };
        events: {
            energyTransferStarted: Event<TypeFromFields<{
                maximumCurrent: FieldType<number | bigint>;
                sessionId: FieldType<number>;
                state: FieldType<EnergyEvse.State>;
            }>, any>;
            energyTransferStopped: Event<TypeFromFields<{
                energyTransferred: FieldType<number | bigint>;
                reason: FieldType<EnergyEvse.EnergyTransferStoppedReason>;
                sessionId: FieldType<number>;
                state: FieldType<EnergyEvse.State>;
            }>, any>;
            evConnected: Event<TypeFromFields<{
                sessionId: FieldType<number>;
            }>, any>;
            evNotDetected: Event<TypeFromFields<{
                sessionDuration: FieldType<number>;
                sessionEnergyCharged: FieldType<number | bigint>;
                sessionEnergyDischarged: OptionalFieldType<number | bigint>;
                sessionId: FieldType<number>;
                state: FieldType<EnergyEvse.State>;
            }>, any>;
            fault: Event<TypeFromFields<{
                faultStateCurrentState: FieldType<EnergyEvse.FaultState>;
                faultStatePreviousState: FieldType<EnergyEvse.FaultState>;
                sessionId: FieldType<null | number>;
                state: FieldType<EnergyEvse.State>;
            }>, any>;
            rfid: OptionalEvent<TypeFromFields<{
                uid: FieldType<Uint8Array>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    rfid: boolean;
                }];
            };
        };
        features: {
            chargingPreferences: BitFlag;
            plugAndCharge: BitFlag;
            rfid: BitFlag;
            soCReporting: BitFlag;
            v2X: BitFlag;
        };
        id: Branded<153, "ClusterId">;
        name: "EnergyEvse";
        revision: 2;
    }>, SelectionT>

  • Select features using ClusterComposer.compose.

    Type Parameters

    • const SelectionT extends FeatureSelection<Of<{
          attributes: {
              acceptedCommandList: Attribute<CommandId[], never>;
              approximateEvEfficiency: OptionalWritableAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      chargingPreferences: boolean;
                  }];
              };
              attributeList: Attribute<AttributeId[], never>;
              batteryCapacity: Attribute<null | number | bigint, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      soCReporting: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              chargingEnabledUntil: Attribute<null | number, any>;
              circuitCapacity: Attribute<number | bigint, any>;
              clusterRevision: Attribute<number, never>;
              dischargingEnabledUntil: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      v2X: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              faultState: Attribute<EnergyEvse.FaultState, any>;
              featureMap: Attribute<TypeFromPartialBitSchema<{
                  chargingPreferences: BitFlag;
                  plugAndCharge: BitFlag;
                  rfid: BitFlag;
                  soCReporting: BitFlag;
                  v2X: BitFlag;
              }>, never>;
              generatedCommandList: Attribute<CommandId[], never>;
              maximumChargeCurrent: Attribute<number | bigint, any>;
              maximumDischargeCurrent: Attribute<number | bigint, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      v2X: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              minimumChargeCurrent: Attribute<number | bigint, any>;
              nextChargeRequiredEnergy: Attribute<null | number | bigint, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      chargingPreferences: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              nextChargeStartTime: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      chargingPreferences: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              nextChargeTargetSoC: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      chargingPreferences: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              nextChargeTargetTime: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      chargingPreferences: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              randomizationDelayWindow: OptionalWritableAttribute<number, any>;
              sessionDuration: Attribute<null | number, any>;
              sessionEnergyCharged: Attribute<null | number | bigint, any>;
              sessionEnergyDischarged: Attribute<null | number | bigint, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      v2X: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              sessionId: Attribute<null | number, any>;
              state: Attribute<null | EnergyEvse.State, any>;
              stateOfCharge: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      soCReporting: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              supplyState: Attribute<EnergyEvse.SupplyState, any>;
              userMaximumChargeCurrent: OptionalWritableAttribute<number | bigint, any>;
              vehicleId: Attribute<null | string, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      plugAndCharge: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          commands: {
              clearTargets: Command<void, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      chargingPreferences: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              disable: Command<void, void, any>;
              enableCharging: Command<TypeFromFields<{
                  chargingEnabledUntil: FieldType<null | number>;
                  maximumChargeCurrent: FieldType<number | bigint>;
                  minimumChargeCurrent: FieldType<number | bigint>;
              }>, void, any>;
              enableDischarging: Command<TypeFromFields<{
                  dischargingEnabledUntil: FieldType<null | number>;
                  maximumDischargeCurrent: FieldType<number | bigint>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      v2X: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              getTargets: Command<void, TypeFromFields<{
                  chargingTargetSchedules: FieldType<TypeFromFields<(...)>[]>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      chargingPreferences: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              setTargets: Command<TypeFromFields<{
                  chargingTargetSchedules: FieldType<TypeFromFields<(...)>[]>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      chargingPreferences: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              startDiagnostics: OptionalCommand<void, void, any>;
          };
          events: {
              energyTransferStarted: Event<TypeFromFields<{
                  maximumCurrent: FieldType<number | bigint>;
                  sessionId: FieldType<number>;
                  state: FieldType<EnergyEvse.State>;
              }>, any>;
              energyTransferStopped: Event<TypeFromFields<{
                  energyTransferred: FieldType<number | bigint>;
                  reason: FieldType<EnergyEvse.EnergyTransferStoppedReason>;
                  sessionId: FieldType<number>;
                  state: FieldType<EnergyEvse.State>;
              }>, any>;
              evConnected: Event<TypeFromFields<{
                  sessionId: FieldType<number>;
              }>, any>;
              evNotDetected: Event<TypeFromFields<{
                  sessionDuration: FieldType<number>;
                  sessionEnergyCharged: FieldType<number | bigint>;
                  sessionEnergyDischarged: OptionalFieldType<number | bigint>;
                  sessionId: FieldType<number>;
                  state: FieldType<EnergyEvse.State>;
              }>, any>;
              fault: Event<TypeFromFields<{
                  faultStateCurrentState: FieldType<EnergyEvse.FaultState>;
                  faultStatePreviousState: FieldType<EnergyEvse.FaultState>;
                  sessionId: FieldType<null | number>;
                  state: FieldType<EnergyEvse.State>;
              }>, any>;
              rfid: OptionalEvent<TypeFromFields<{
                  uid: FieldType<Uint8Array>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      rfid: boolean;
                  }];
              };
          };
          features: {
              chargingPreferences: BitFlag;
              plugAndCharge: BitFlag;
              rfid: BitFlag;
              soCReporting: BitFlag;
              v2X: BitFlag;
          };
          id: Branded<153, "ClusterId">;
          name: "EnergyEvse";
          revision: 2;
      }>>

    Parameters

    Returns Of<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            approximateEvEfficiency: OptionalWritableAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    chargingPreferences: boolean;
                }];
            };
            attributeList: Attribute<AttributeId[], never>;
            batteryCapacity: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    soCReporting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            chargingEnabledUntil: Attribute<null | number, any>;
            circuitCapacity: Attribute<number | bigint, any>;
            clusterRevision: Attribute<number, never>;
            dischargingEnabledUntil: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    v2X: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            faultState: Attribute<EnergyEvse.FaultState, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                chargingPreferences: BitFlag;
                plugAndCharge: BitFlag;
                rfid: BitFlag;
                soCReporting: BitFlag;
                v2X: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maximumChargeCurrent: Attribute<number | bigint, any>;
            maximumDischargeCurrent: Attribute<number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    v2X: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minimumChargeCurrent: Attribute<number | bigint, any>;
            nextChargeRequiredEnergy: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            nextChargeStartTime: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            nextChargeTargetSoC: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            nextChargeTargetTime: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            randomizationDelayWindow: OptionalWritableAttribute<number, any>;
            sessionDuration: Attribute<null | number, any>;
            sessionEnergyCharged: Attribute<null | number | bigint, any>;
            sessionEnergyDischarged: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    v2X: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            sessionId: Attribute<null | number, any>;
            state: Attribute<null | EnergyEvse.State, any>;
            stateOfCharge: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    soCReporting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supplyState: Attribute<EnergyEvse.SupplyState, any>;
            userMaximumChargeCurrent: OptionalWritableAttribute<number | bigint, any>;
            vehicleId: Attribute<null | string, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    plugAndCharge: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            clearTargets: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            disable: Command<void, void, any>;
            enableCharging: Command<TypeFromFields<{
                chargingEnabledUntil: FieldType<null | number>;
                maximumChargeCurrent: FieldType<number | bigint>;
                minimumChargeCurrent: FieldType<number | bigint>;
            }>, void, any>;
            enableDischarging: Command<TypeFromFields<{
                dischargingEnabledUntil: FieldType<null | number>;
                maximumDischargeCurrent: FieldType<number | bigint>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    v2X: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getTargets: Command<void, TypeFromFields<{
                chargingTargetSchedules: FieldType<TypeFromFields<(...)>[]>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setTargets: Command<TypeFromFields<{
                chargingTargetSchedules: FieldType<TypeFromFields<(...)>[]>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    chargingPreferences: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            startDiagnostics: OptionalCommand<void, void, any>;
        };
        events: {
            energyTransferStarted: Event<TypeFromFields<{
                maximumCurrent: FieldType<number | bigint>;
                sessionId: FieldType<number>;
                state: FieldType<EnergyEvse.State>;
            }>, any>;
            energyTransferStopped: Event<TypeFromFields<{
                energyTransferred: FieldType<number | bigint>;
                reason: FieldType<EnergyEvse.EnergyTransferStoppedReason>;
                sessionId: FieldType<number>;
                state: FieldType<EnergyEvse.State>;
            }>, any>;
            evConnected: Event<TypeFromFields<{
                sessionId: FieldType<number>;
            }>, any>;
            evNotDetected: Event<TypeFromFields<{
                sessionDuration: FieldType<number>;
                sessionEnergyCharged: FieldType<number | bigint>;
                sessionEnergyDischarged: OptionalFieldType<number | bigint>;
                sessionId: FieldType<number>;
                state: FieldType<EnergyEvse.State>;
            }>, any>;
            fault: Event<TypeFromFields<{
                faultStateCurrentState: FieldType<EnergyEvse.FaultState>;
                faultStatePreviousState: FieldType<EnergyEvse.FaultState>;
                sessionId: FieldType<null | number>;
                state: FieldType<EnergyEvse.State>;
            }>, any>;
            rfid: OptionalEvent<TypeFromFields<{
                uid: FieldType<Uint8Array>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    rfid: boolean;
                }];
            };
        };
        features: {
            chargingPreferences: BitFlag;
            plugAndCharge: BitFlag;
            rfid: BitFlag;
            soCReporting: BitFlag;
            v2X: BitFlag;
        };
        id: Branded<153, "ClusterId">;
        name: "EnergyEvse";
        revision: 2;
    }>, SelectionT>

Settings

Member Visibility

On This Page

Properties
Methods