Interface Complete

This cluster supports all ElectricalEnergyMeasurement 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<{
        accuracy: FixedAttribute<TypeFromFields<{
            accuracyRanges: FieldType<TypeFromFields<{
                fixedMax: OptionalFieldType<(...) | (...)>;
                fixedMin: OptionalFieldType<(...) | (...)>;
                fixedTypical: OptionalFieldType<(...) | (...)>;
                percentMax: OptionalFieldType<number>;
                percentMin: OptionalFieldType<number>;
                percentTypical: OptionalFieldType<number>;
                rangeMax: FieldType<(...) | (...)>;
                rangeMin: FieldType<(...) | (...)>;
            }>[]>;
            maxMeasuredValue: FieldType<number | bigint>;
            measured: FieldType<boolean>;
            measurementType: FieldType<MeasurementType>;
            minMeasuredValue: FieldType<number | bigint>;
        }>, any>;
        cumulativeEnergyExported: Attribute<null | TypeFromFields<{
            endSystime: OptionalFieldType<number | bigint>;
            endTimestamp: OptionalFieldType<number>;
            energy: FieldType<number | bigint>;
            startSystime: OptionalFieldType<number | bigint>;
            startTimestamp: OptionalFieldType<number>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                cumulativeEnergy: boolean;
                exportedEnergy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        cumulativeEnergyImported: Attribute<null | TypeFromFields<{
            endSystime: OptionalFieldType<number | bigint>;
            endTimestamp: OptionalFieldType<number>;
            energy: FieldType<number | bigint>;
            startSystime: OptionalFieldType<number | bigint>;
            startTimestamp: OptionalFieldType<number>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                cumulativeEnergy: boolean;
                importedEnergy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        cumulativeEnergyReset: OptionalAttribute<null | TypeFromFields<{
            exportedResetSystime: OptionalFieldType<null | number | bigint>;
            exportedResetTimestamp: OptionalFieldType<null | number>;
            importedResetSystime: OptionalFieldType<null | number | bigint>;
            importedResetTimestamp: OptionalFieldType<null | number>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                cumulativeEnergy: boolean;
            }];
        };
        periodicEnergyExported: Attribute<null | TypeFromFields<{
            endSystime: OptionalFieldType<number | bigint>;
            endTimestamp: OptionalFieldType<number>;
            energy: FieldType<number | bigint>;
            startSystime: OptionalFieldType<number | bigint>;
            startTimestamp: OptionalFieldType<number>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                exportedEnergy: boolean;
                periodicEnergy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        periodicEnergyImported: Attribute<null | TypeFromFields<{
            endSystime: OptionalFieldType<number | bigint>;
            endTimestamp: OptionalFieldType<number>;
            energy: FieldType<number | bigint>;
            startSystime: OptionalFieldType<number | bigint>;
            startTimestamp: OptionalFieldType<number>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                importedEnergy: boolean;
                periodicEnergy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    }, GlobalAttributes<{
        cumulativeEnergy: BitFlag;
        exportedEnergy: BitFlag;
        importedEnergy: BitFlag;
        periodicEnergy: BitFlag;
    }>>;
    base: undefined;
    commands: {};
    events: {
        cumulativeEnergyMeasured: Event<TypeFromFields<{
            energyExported: OptionalFieldType<TypeFromFields<{
                endSystime: OptionalFieldType<number | bigint>;
                endTimestamp: OptionalFieldType<number>;
                energy: FieldType<number | bigint>;
                startSystime: OptionalFieldType<number | bigint>;
                startTimestamp: OptionalFieldType<number>;
            }>>;
            energyImported: OptionalFieldType<TypeFromFields<{
                endSystime: OptionalFieldType<number | bigint>;
                endTimestamp: OptionalFieldType<number>;
                energy: FieldType<number | bigint>;
                startSystime: OptionalFieldType<number | bigint>;
                startTimestamp: OptionalFieldType<number>;
            }>>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                cumulativeEnergy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        periodicEnergyMeasured: Event<TypeFromFields<{
            energyExported: OptionalFieldType<TypeFromFields<{
                endSystime: OptionalFieldType<number | bigint>;
                endTimestamp: OptionalFieldType<number>;
                energy: FieldType<number | bigint>;
                startSystime: OptionalFieldType<number | bigint>;
                startTimestamp: OptionalFieldType<number>;
            }>>;
            energyImported: OptionalFieldType<TypeFromFields<{
                endSystime: OptionalFieldType<number | bigint>;
                endTimestamp: OptionalFieldType<number>;
                energy: FieldType<number | bigint>;
                startSystime: OptionalFieldType<number | bigint>;
                startTimestamp: OptionalFieldType<number>;
            }>>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                periodicEnergy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    extensions: undefined;
    features: {
        cumulativeEnergy: BitFlag;
        exportedEnergy: BitFlag;
        importedEnergy: BitFlag;
        periodicEnergy: BitFlag;
    };
    id: Branded<145, "ClusterId">;
    name: "ElectricalEnergyMeasurement";
    revision: 1;
    supportedFeatures: {};
    unknown: false;
    alter<const AlterationsT>(alterations: AlterationsT): WithAlterations<Of<{
        attributes: {
            accuracy: FixedAttribute<TypeFromFields<{
                accuracyRanges: FieldType<TypeFromFields<{
                    fixedMax: ...;
                    fixedMin: ...;
                    fixedTypical: ...;
                    percentMax: ...;
                    percentMin: ...;
                    percentTypical: ...;
                    rangeMax: ...;
                    rangeMin: ...;
                }>[]>;
                maxMeasuredValue: FieldType<number | bigint>;
                measured: FieldType<boolean>;
                measurementType: FieldType<MeasurementType>;
                minMeasuredValue: FieldType<number | bigint>;
            }>, any>;
            cumulativeEnergyExported: Attribute<null | TypeFromFields<{
                endSystime: OptionalFieldType<(...) | (...)>;
                endTimestamp: OptionalFieldType<number>;
                energy: FieldType<(...) | (...)>;
                startSystime: OptionalFieldType<(...) | (...)>;
                startTimestamp: OptionalFieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    cumulativeEnergy: boolean;
                    exportedEnergy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            cumulativeEnergyImported: Attribute<null | TypeFromFields<{
                endSystime: OptionalFieldType<(...) | (...)>;
                endTimestamp: OptionalFieldType<number>;
                energy: FieldType<(...) | (...)>;
                startSystime: OptionalFieldType<(...) | (...)>;
                startTimestamp: OptionalFieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    cumulativeEnergy: boolean;
                    importedEnergy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            cumulativeEnergyReset: OptionalAttribute<null | TypeFromFields<{
                exportedResetSystime: OptionalFieldType<(...) | (...) | (...)>;
                exportedResetTimestamp: OptionalFieldType<(...) | (...)>;
                importedResetSystime: OptionalFieldType<(...) | (...) | (...)>;
                importedResetTimestamp: OptionalFieldType<(...) | (...)>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    cumulativeEnergy: boolean;
                }];
            };
            periodicEnergyExported: Attribute<null | TypeFromFields<{
                endSystime: OptionalFieldType<(...) | (...)>;
                endTimestamp: OptionalFieldType<number>;
                energy: FieldType<(...) | (...)>;
                startSystime: OptionalFieldType<(...) | (...)>;
                startTimestamp: OptionalFieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    exportedEnergy: boolean;
                    periodicEnergy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            periodicEnergyImported: Attribute<null | TypeFromFields<{
                endSystime: OptionalFieldType<(...) | (...)>;
                endTimestamp: OptionalFieldType<number>;
                energy: FieldType<(...) | (...)>;
                startSystime: OptionalFieldType<(...) | (...)>;
                startTimestamp: OptionalFieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    importedEnergy: boolean;
                    periodicEnergy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        events: {
            cumulativeEnergyMeasured: Event<TypeFromFields<{
                energyExported: OptionalFieldType<TypeFromFields<{
                    endSystime: ...;
                    endTimestamp: ...;
                    energy: ...;
                    startSystime: ...;
                    startTimestamp: ...;
                }>>;
                energyImported: OptionalFieldType<TypeFromFields<{
                    endSystime: ...;
                    endTimestamp: ...;
                    energy: ...;
                    startSystime: ...;
                    startTimestamp: ...;
                }>>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    cumulativeEnergy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            periodicEnergyMeasured: Event<TypeFromFields<{
                energyExported: OptionalFieldType<TypeFromFields<{
                    endSystime: ...;
                    endTimestamp: ...;
                    energy: ...;
                    startSystime: ...;
                    startTimestamp: ...;
                }>>;
                energyImported: OptionalFieldType<TypeFromFields<{
                    endSystime: ...;
                    endTimestamp: ...;
                    energy: ...;
                    startSystime: ...;
                    startTimestamp: ...;
                }>>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    periodicEnergy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            cumulativeEnergy: BitFlag;
            exportedEnergy: BitFlag;
            importedEnergy: BitFlag;
            periodicEnergy: BitFlag;
        };
        id: 145;
        name: "ElectricalEnergyMeasurement";
        revision: 1;
    }>, AlterationsT>;
    enable<const FlagsT>(flags: FlagsT): WithFlags<Of<{
        attributes: {
            accuracy: FixedAttribute<TypeFromFields<{
                accuracyRanges: FieldType<TypeFromFields<{
                    fixedMax: ...;
                    fixedMin: ...;
                    fixedTypical: ...;
                    percentMax: ...;
                    percentMin: ...;
                    percentTypical: ...;
                    rangeMax: ...;
                    rangeMin: ...;
                }>[]>;
                maxMeasuredValue: FieldType<number | bigint>;
                measured: FieldType<boolean>;
                measurementType: FieldType<MeasurementType>;
                minMeasuredValue: FieldType<number | bigint>;
            }>, any>;
            cumulativeEnergyExported: Attribute<null | TypeFromFields<{
                endSystime: OptionalFieldType<(...) | (...)>;
                endTimestamp: OptionalFieldType<number>;
                energy: FieldType<(...) | (...)>;
                startSystime: OptionalFieldType<(...) | (...)>;
                startTimestamp: OptionalFieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    cumulativeEnergy: boolean;
                    exportedEnergy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            cumulativeEnergyImported: Attribute<null | TypeFromFields<{
                endSystime: OptionalFieldType<(...) | (...)>;
                endTimestamp: OptionalFieldType<number>;
                energy: FieldType<(...) | (...)>;
                startSystime: OptionalFieldType<(...) | (...)>;
                startTimestamp: OptionalFieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    cumulativeEnergy: boolean;
                    importedEnergy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            cumulativeEnergyReset: OptionalAttribute<null | TypeFromFields<{
                exportedResetSystime: OptionalFieldType<(...) | (...) | (...)>;
                exportedResetTimestamp: OptionalFieldType<(...) | (...)>;
                importedResetSystime: OptionalFieldType<(...) | (...) | (...)>;
                importedResetTimestamp: OptionalFieldType<(...) | (...)>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    cumulativeEnergy: boolean;
                }];
            };
            periodicEnergyExported: Attribute<null | TypeFromFields<{
                endSystime: OptionalFieldType<(...) | (...)>;
                endTimestamp: OptionalFieldType<number>;
                energy: FieldType<(...) | (...)>;
                startSystime: OptionalFieldType<(...) | (...)>;
                startTimestamp: OptionalFieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    exportedEnergy: boolean;
                    periodicEnergy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            periodicEnergyImported: Attribute<null | TypeFromFields<{
                endSystime: OptionalFieldType<(...) | (...)>;
                endTimestamp: OptionalFieldType<number>;
                energy: FieldType<(...) | (...)>;
                startSystime: OptionalFieldType<(...) | (...)>;
                startTimestamp: OptionalFieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    importedEnergy: boolean;
                    periodicEnergy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        events: {
            cumulativeEnergyMeasured: Event<TypeFromFields<{
                energyExported: OptionalFieldType<TypeFromFields<{
                    endSystime: ...;
                    endTimestamp: ...;
                    energy: ...;
                    startSystime: ...;
                    startTimestamp: ...;
                }>>;
                energyImported: OptionalFieldType<TypeFromFields<{
                    endSystime: ...;
                    endTimestamp: ...;
                    energy: ...;
                    startSystime: ...;
                    startTimestamp: ...;
                }>>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    cumulativeEnergy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            periodicEnergyMeasured: Event<TypeFromFields<{
                energyExported: OptionalFieldType<TypeFromFields<{
                    endSystime: ...;
                    endTimestamp: ...;
                    energy: ...;
                    startSystime: ...;
                    startTimestamp: ...;
                }>>;
                energyImported: OptionalFieldType<TypeFromFields<{
                    endSystime: ...;
                    endTimestamp: ...;
                    energy: ...;
                    startSystime: ...;
                    startTimestamp: ...;
                }>>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    periodicEnergy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            cumulativeEnergy: BitFlag;
            exportedEnergy: BitFlag;
            importedEnergy: BitFlag;
            periodicEnergy: BitFlag;
        };
        id: 145;
        name: "ElectricalEnergyMeasurement";
        revision: 1;
    }>, FlagsT>;
    set<const ValuesT>(values: ValuesT): WithValues<Of<{
        attributes: {
            accuracy: FixedAttribute<TypeFromFields<{
                accuracyRanges: FieldType<TypeFromFields<{
                    fixedMax: ...;
                    fixedMin: ...;
                    fixedTypical: ...;
                    percentMax: ...;
                    percentMin: ...;
                    percentTypical: ...;
                    rangeMax: ...;
                    rangeMin: ...;
                }>[]>;
                maxMeasuredValue: FieldType<number | bigint>;
                measured: FieldType<boolean>;
                measurementType: FieldType<MeasurementType>;
                minMeasuredValue: FieldType<number | bigint>;
            }>, any>;
            cumulativeEnergyExported: Attribute<null | TypeFromFields<{
                endSystime: OptionalFieldType<(...) | (...)>;
                endTimestamp: OptionalFieldType<number>;
                energy: FieldType<(...) | (...)>;
                startSystime: OptionalFieldType<(...) | (...)>;
                startTimestamp: OptionalFieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    cumulativeEnergy: boolean;
                    exportedEnergy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            cumulativeEnergyImported: Attribute<null | TypeFromFields<{
                endSystime: OptionalFieldType<(...) | (...)>;
                endTimestamp: OptionalFieldType<number>;
                energy: FieldType<(...) | (...)>;
                startSystime: OptionalFieldType<(...) | (...)>;
                startTimestamp: OptionalFieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    cumulativeEnergy: boolean;
                    importedEnergy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            cumulativeEnergyReset: OptionalAttribute<null | TypeFromFields<{
                exportedResetSystime: OptionalFieldType<(...) | (...) | (...)>;
                exportedResetTimestamp: OptionalFieldType<(...) | (...)>;
                importedResetSystime: OptionalFieldType<(...) | (...) | (...)>;
                importedResetTimestamp: OptionalFieldType<(...) | (...)>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    cumulativeEnergy: boolean;
                }];
            };
            periodicEnergyExported: Attribute<null | TypeFromFields<{
                endSystime: OptionalFieldType<(...) | (...)>;
                endTimestamp: OptionalFieldType<number>;
                energy: FieldType<(...) | (...)>;
                startSystime: OptionalFieldType<(...) | (...)>;
                startTimestamp: OptionalFieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    exportedEnergy: boolean;
                    periodicEnergy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            periodicEnergyImported: Attribute<null | TypeFromFields<{
                endSystime: OptionalFieldType<(...) | (...)>;
                endTimestamp: OptionalFieldType<number>;
                energy: FieldType<(...) | (...)>;
                startSystime: OptionalFieldType<(...) | (...)>;
                startTimestamp: OptionalFieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    importedEnergy: boolean;
                    periodicEnergy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        events: {
            cumulativeEnergyMeasured: Event<TypeFromFields<{
                energyExported: OptionalFieldType<TypeFromFields<{
                    endSystime: ...;
                    endTimestamp: ...;
                    energy: ...;
                    startSystime: ...;
                    startTimestamp: ...;
                }>>;
                energyImported: OptionalFieldType<TypeFromFields<{
                    endSystime: ...;
                    endTimestamp: ...;
                    energy: ...;
                    startSystime: ...;
                    startTimestamp: ...;
                }>>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    cumulativeEnergy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            periodicEnergyMeasured: Event<TypeFromFields<{
                energyExported: OptionalFieldType<TypeFromFields<{
                    endSystime: ...;
                    endTimestamp: ...;
                    energy: ...;
                    startSystime: ...;
                    startTimestamp: ...;
                }>>;
                energyImported: OptionalFieldType<TypeFromFields<{
                    endSystime: ...;
                    endTimestamp: ...;
                    energy: ...;
                    startSystime: ...;
                    startTimestamp: ...;
                }>>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    periodicEnergy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            cumulativeEnergy: BitFlag;
            exportedEnergy: BitFlag;
            importedEnergy: BitFlag;
            periodicEnergy: BitFlag;
        };
        id: 145;
        name: "ElectricalEnergyMeasurement";
        revision: 1;
    }>, ValuesT>;
    with<const SelectionT>(...selection: SelectionT): Of<Of<{
        attributes: {
            accuracy: FixedAttribute<TypeFromFields<{
                accuracyRanges: FieldType<TypeFromFields<{
                    fixedMax: ...;
                    fixedMin: ...;
                    fixedTypical: ...;
                    percentMax: ...;
                    percentMin: ...;
                    percentTypical: ...;
                    rangeMax: ...;
                    rangeMin: ...;
                }>[]>;
                maxMeasuredValue: FieldType<number | bigint>;
                measured: FieldType<boolean>;
                measurementType: FieldType<MeasurementType>;
                minMeasuredValue: FieldType<number | bigint>;
            }>, any>;
            cumulativeEnergyExported: Attribute<null | TypeFromFields<{
                endSystime: OptionalFieldType<(...) | (...)>;
                endTimestamp: OptionalFieldType<number>;
                energy: FieldType<(...) | (...)>;
                startSystime: OptionalFieldType<(...) | (...)>;
                startTimestamp: OptionalFieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    cumulativeEnergy: boolean;
                    exportedEnergy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            cumulativeEnergyImported: Attribute<null | TypeFromFields<{
                endSystime: OptionalFieldType<(...) | (...)>;
                endTimestamp: OptionalFieldType<number>;
                energy: FieldType<(...) | (...)>;
                startSystime: OptionalFieldType<(...) | (...)>;
                startTimestamp: OptionalFieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    cumulativeEnergy: boolean;
                    importedEnergy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            cumulativeEnergyReset: OptionalAttribute<null | TypeFromFields<{
                exportedResetSystime: OptionalFieldType<(...) | (...) | (...)>;
                exportedResetTimestamp: OptionalFieldType<(...) | (...)>;
                importedResetSystime: OptionalFieldType<(...) | (...) | (...)>;
                importedResetTimestamp: OptionalFieldType<(...) | (...)>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    cumulativeEnergy: boolean;
                }];
            };
            periodicEnergyExported: Attribute<null | TypeFromFields<{
                endSystime: OptionalFieldType<(...) | (...)>;
                endTimestamp: OptionalFieldType<number>;
                energy: FieldType<(...) | (...)>;
                startSystime: OptionalFieldType<(...) | (...)>;
                startTimestamp: OptionalFieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    exportedEnergy: boolean;
                    periodicEnergy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            periodicEnergyImported: Attribute<null | TypeFromFields<{
                endSystime: OptionalFieldType<(...) | (...)>;
                endTimestamp: OptionalFieldType<number>;
                energy: FieldType<(...) | (...)>;
                startSystime: OptionalFieldType<(...) | (...)>;
                startTimestamp: OptionalFieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    importedEnergy: boolean;
                    periodicEnergy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        events: {
            cumulativeEnergyMeasured: Event<TypeFromFields<{
                energyExported: OptionalFieldType<TypeFromFields<{
                    endSystime: ...;
                    endTimestamp: ...;
                    energy: ...;
                    startSystime: ...;
                    startTimestamp: ...;
                }>>;
                energyImported: OptionalFieldType<TypeFromFields<{
                    endSystime: ...;
                    endTimestamp: ...;
                    energy: ...;
                    startSystime: ...;
                    startTimestamp: ...;
                }>>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    cumulativeEnergy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            periodicEnergyMeasured: Event<TypeFromFields<{
                energyExported: OptionalFieldType<TypeFromFields<{
                    endSystime: ...;
                    endTimestamp: ...;
                    energy: ...;
                    startSystime: ...;
                    startTimestamp: ...;
                }>>;
                energyImported: OptionalFieldType<TypeFromFields<{
                    endSystime: ...;
                    endTimestamp: ...;
                    energy: ...;
                    startSystime: ...;
                    startTimestamp: ...;
                }>>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    periodicEnergy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            cumulativeEnergy: BitFlag;
            exportedEnergy: BitFlag;
            importedEnergy: BitFlag;
            periodicEnergy: BitFlag;
        };
        id: 145;
        name: "ElectricalEnergyMeasurement";
        revision: 1;
    }>, SelectionT>;
}

Hierarchy (view full)

Identity<typeof ElectricalEnergyMeasurement.CompleteInstance>
- Complete

Index

Properties

attributes base commands events extensions features id name revision supportedFeatures unknown

Methods

alter enable set with

Properties

attributes

attributes: Merge<{
    accuracy: FixedAttribute<TypeFromFields<{
        accuracyRanges: FieldType<TypeFromFields<{
            fixedMax: OptionalFieldType<(...) | (...)>;
            fixedMin: OptionalFieldType<(...) | (...)>;
            fixedTypical: OptionalFieldType<(...) | (...)>;
            percentMax: OptionalFieldType<number>;
            percentMin: OptionalFieldType<number>;
            percentTypical: OptionalFieldType<number>;
            rangeMax: FieldType<(...) | (...)>;
            rangeMin: FieldType<(...) | (...)>;
        }>[]>;
        maxMeasuredValue: FieldType<number | bigint>;
        measured: FieldType<boolean>;
        measurementType: FieldType<MeasurementType>;
        minMeasuredValue: FieldType<number | bigint>;
    }>, any>;
    cumulativeEnergyExported: Attribute<null | TypeFromFields<{
        endSystime: OptionalFieldType<number | bigint>;
        endTimestamp: OptionalFieldType<number>;
        energy: FieldType<number | bigint>;
        startSystime: OptionalFieldType<number | bigint>;
        startTimestamp: OptionalFieldType<number>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            cumulativeEnergy: boolean;
            exportedEnergy: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    cumulativeEnergyImported: Attribute<null | TypeFromFields<{
        endSystime: OptionalFieldType<number | bigint>;
        endTimestamp: OptionalFieldType<number>;
        energy: FieldType<number | bigint>;
        startSystime: OptionalFieldType<number | bigint>;
        startTimestamp: OptionalFieldType<number>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            cumulativeEnergy: boolean;
            importedEnergy: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    cumulativeEnergyReset: OptionalAttribute<null | TypeFromFields<{
        exportedResetSystime: OptionalFieldType<null | number | bigint>;
        exportedResetTimestamp: OptionalFieldType<null | number>;
        importedResetSystime: OptionalFieldType<null | number | bigint>;
        importedResetTimestamp: OptionalFieldType<null | number>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            cumulativeEnergy: boolean;
        }];
    };
    periodicEnergyExported: Attribute<null | TypeFromFields<{
        endSystime: OptionalFieldType<number | bigint>;
        endTimestamp: OptionalFieldType<number>;
        energy: FieldType<number | bigint>;
        startSystime: OptionalFieldType<number | bigint>;
        startTimestamp: OptionalFieldType<number>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            exportedEnergy: boolean;
            periodicEnergy: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    periodicEnergyImported: Attribute<null | TypeFromFields<{
        endSystime: OptionalFieldType<number | bigint>;
        endTimestamp: OptionalFieldType<number>;
        energy: FieldType<number | bigint>;
        startSystime: OptionalFieldType<number | bigint>;
        startTimestamp: OptionalFieldType<number>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            importedEnergy: boolean;
            periodicEnergy: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
}, GlobalAttributes<{
    cumulativeEnergy: BitFlag;
    exportedEnergy: BitFlag;
    importedEnergy: BitFlag;
    periodicEnergy: BitFlag;
}>>

Type declaration

Readonlyaccuracy: FixedAttribute<TypeFromFields<{
    accuracyRanges: FieldType<TypeFromFields<{
        fixedMax: OptionalFieldType<(...) | (...)>;
        fixedMin: OptionalFieldType<(...) | (...)>;
        fixedTypical: OptionalFieldType<(...) | (...)>;
        percentMax: OptionalFieldType<number>;
        percentMin: OptionalFieldType<number>;
        percentTypical: OptionalFieldType<number>;
        rangeMax: FieldType<(...) | (...)>;
        rangeMin: FieldType<(...) | (...)>;
    }>[]>;
    maxMeasuredValue: FieldType<number | bigint>;
    measured: FieldType<boolean>;
    measurementType: FieldType<MeasurementType>;
    minMeasuredValue: FieldType<number | bigint>;
}>, any>
Indicates the accuracy of energy measurement by this server. The value of the MeasurementType field on this MeasurementAccuracyStruct shall be ElectricalEnergy.

See
MatterSpecification.v13.Cluster § 2.12.6.1
ReadonlycumulativeEnergyExported: Attribute<null | TypeFromFields<{
    endSystime: OptionalFieldType<number | bigint>;
    endTimestamp: OptionalFieldType<number>;
    energy: FieldType<number | bigint>;
    startSystime: OptionalFieldType<number | bigint>;
    startTimestamp: OptionalFieldType<number>;
}>, any> & {
    isConditional: true;
    mandatoryIf: [] | [{
        cumulativeEnergy: boolean;
        exportedEnergy: boolean;
    }];
    optional: true;
    optionalIf: [] | ConditionalFeatureList<BitSchema>;
}
ReadonlycumulativeEnergyImported: Attribute<null | TypeFromFields<{
    endSystime: OptionalFieldType<number | bigint>;
    endTimestamp: OptionalFieldType<number>;
    energy: FieldType<number | bigint>;
    startSystime: OptionalFieldType<number | bigint>;
    startTimestamp: OptionalFieldType<number>;
}>, any> & {
    isConditional: true;
    mandatoryIf: [] | [{
        cumulativeEnergy: boolean;
        importedEnergy: boolean;
    }];
    optional: true;
    optionalIf: [] | ConditionalFeatureList<BitSchema>;
}
ReadonlycumulativeEnergyReset: OptionalAttribute<null | TypeFromFields<{
    exportedResetSystime: OptionalFieldType<null | number | bigint>;
    exportedResetTimestamp: OptionalFieldType<null | number>;
    importedResetSystime: OptionalFieldType<null | number | bigint>;
    importedResetTimestamp: OptionalFieldType<null | number>;
}>, any> & {
    isConditional: true;
    mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
    optional: true;
    optionalIf: [] | [{
        cumulativeEnergy: boolean;
    }];
}
ReadonlyperiodicEnergyExported: Attribute<null | TypeFromFields<{
    endSystime: OptionalFieldType<number | bigint>;
    endTimestamp: OptionalFieldType<number>;
    energy: FieldType<number | bigint>;
    startSystime: OptionalFieldType<number | bigint>;
    startTimestamp: OptionalFieldType<number>;
}>, any> & {
    isConditional: true;
    mandatoryIf: [] | [{
        exportedEnergy: boolean;
        periodicEnergy: boolean;
    }];
    optional: true;
    optionalIf: [] | ConditionalFeatureList<BitSchema>;
}
ReadonlyperiodicEnergyImported: Attribute<null | TypeFromFields<{
    endSystime: OptionalFieldType<number | bigint>;
    endTimestamp: OptionalFieldType<number>;
    energy: FieldType<number | bigint>;
    startSystime: OptionalFieldType<number | bigint>;
    startTimestamp: OptionalFieldType<number>;
}>, any> & {
    isConditional: true;
    mandatoryIf: [] | [{
        importedEnergy: boolean;
        periodicEnergy: boolean;
    }];
    optional: true;
    optionalIf: [] | ConditionalFeatureList<BitSchema>;
}

base

base: undefined

commands

commands: {}

events

events: {
    cumulativeEnergyMeasured: Event<TypeFromFields<{
        energyExported: OptionalFieldType<TypeFromFields<{
            endSystime: OptionalFieldType<number | bigint>;
            endTimestamp: OptionalFieldType<number>;
            energy: FieldType<number | bigint>;
            startSystime: OptionalFieldType<number | bigint>;
            startTimestamp: OptionalFieldType<number>;
        }>>;
        energyImported: OptionalFieldType<TypeFromFields<{
            endSystime: OptionalFieldType<number | bigint>;
            endTimestamp: OptionalFieldType<number>;
            energy: FieldType<number | bigint>;
            startSystime: OptionalFieldType<number | bigint>;
            startTimestamp: OptionalFieldType<number>;
        }>>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            cumulativeEnergy: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    periodicEnergyMeasured: Event<TypeFromFields<{
        energyExported: OptionalFieldType<TypeFromFields<{
            endSystime: OptionalFieldType<number | bigint>;
            endTimestamp: OptionalFieldType<number>;
            energy: FieldType<number | bigint>;
            startSystime: OptionalFieldType<number | bigint>;
            startTimestamp: OptionalFieldType<number>;
        }>>;
        energyImported: OptionalFieldType<TypeFromFields<{
            endSystime: OptionalFieldType<number | bigint>;
            endTimestamp: OptionalFieldType<number>;
            energy: FieldType<number | bigint>;
            startSystime: OptionalFieldType<number | bigint>;
            startTimestamp: OptionalFieldType<number>;
        }>>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            periodicEnergy: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
}

extensions

extensions: undefined

features

features: {
    cumulativeEnergy: BitFlag;
    exportedEnergy: BitFlag;
    importedEnergy: BitFlag;
    periodicEnergy: BitFlag;
}

Type declaration

ReadonlycumulativeEnergy: BitFlag
CumulativeEnergy

The feature indicates the server is capable of measuring how much energy has been imported or exported by the server over the device’s lifetime. This measurement may start from when a device’s firmware is updated to include this feature, when a device’s firmware is updated to correct measurement errors, or when a device is factory reset.

See
MatterSpecification.v13.Cluster § 2.12.4.3
ReadonlyexportedEnergy: BitFlag
ExportedEnergy

The feature indicates the server is capable of measuring how much energy is exported by the server.

See
MatterSpecification.v13.Cluster § 2.12.4.2
ReadonlyimportedEnergy: BitFlag
ImportedEnergy

The feature indicates the server is capable of measuring how much energy is imported by the server.

See
MatterSpecification.v13.Cluster § 2.12.4.1
ReadonlyperiodicEnergy: BitFlag
PeriodicEnergy

The feature indicates the server is capable of measuring how much energy has been imported or exported by the server during a certain period of time. The start and end times for measurement periods shall be determined by the server, and may represent overlapping periods.

See
MatterSpecification.v13.Cluster § 2.12.4.4

id

id: Branded<145, "ClusterId">

name

revision

supportedFeatures

supportedFeatures: {}

unknown

Methods

alter

alter<const AlterationsT>(alterations): WithAlterations<Of<{
    attributes: {
        accuracy: FixedAttribute<TypeFromFields<{
            accuracyRanges: FieldType<TypeFromFields<{
                fixedMax: ...;
                fixedMin: ...;
                fixedTypical: ...;
                percentMax: ...;
                percentMin: ...;
                percentTypical: ...;
                rangeMax: ...;
                rangeMin: ...;
            }>[]>;
            maxMeasuredValue: FieldType<number | bigint>;
            measured: FieldType<boolean>;
            measurementType: FieldType<MeasurementType>;
            minMeasuredValue: FieldType<number | bigint>;
        }>, any>;
        cumulativeEnergyExported: Attribute<null | TypeFromFields<{
            endSystime: OptionalFieldType<(...) | (...)>;
            endTimestamp: OptionalFieldType<number>;
            energy: FieldType<(...) | (...)>;
            startSystime: OptionalFieldType<(...) | (...)>;
            startTimestamp: OptionalFieldType<number>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                cumulativeEnergy: boolean;
                exportedEnergy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        cumulativeEnergyImported: Attribute<null | TypeFromFields<{
            endSystime: OptionalFieldType<(...) | (...)>;
            endTimestamp: OptionalFieldType<number>;
            energy: FieldType<(...) | (...)>;
            startSystime: OptionalFieldType<(...) | (...)>;
            startTimestamp: OptionalFieldType<number>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                cumulativeEnergy: boolean;
                importedEnergy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        cumulativeEnergyReset: OptionalAttribute<null | TypeFromFields<{
            exportedResetSystime: OptionalFieldType<(...) | (...) | (...)>;
            exportedResetTimestamp: OptionalFieldType<(...) | (...)>;
            importedResetSystime: OptionalFieldType<(...) | (...) | (...)>;
            importedResetTimestamp: OptionalFieldType<(...) | (...)>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                cumulativeEnergy: boolean;
            }];
        };
        periodicEnergyExported: Attribute<null | TypeFromFields<{
            endSystime: OptionalFieldType<(...) | (...)>;
            endTimestamp: OptionalFieldType<number>;
            energy: FieldType<(...) | (...)>;
            startSystime: OptionalFieldType<(...) | (...)>;
            startTimestamp: OptionalFieldType<number>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                exportedEnergy: boolean;
                periodicEnergy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        periodicEnergyImported: Attribute<null | TypeFromFields<{
            endSystime: OptionalFieldType<(...) | (...)>;
            endTimestamp: OptionalFieldType<number>;
            energy: FieldType<(...) | (...)>;
            startSystime: OptionalFieldType<(...) | (...)>;
            startTimestamp: OptionalFieldType<number>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                importedEnergy: boolean;
                periodicEnergy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    events: {
        cumulativeEnergyMeasured: Event<TypeFromFields<{
            energyExported: OptionalFieldType<TypeFromFields<{
                endSystime: ...;
                endTimestamp: ...;
                energy: ...;
                startSystime: ...;
                startTimestamp: ...;
            }>>;
            energyImported: OptionalFieldType<TypeFromFields<{
                endSystime: ...;
                endTimestamp: ...;
                energy: ...;
                startSystime: ...;
                startTimestamp: ...;
            }>>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                cumulativeEnergy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        periodicEnergyMeasured: Event<TypeFromFields<{
            energyExported: OptionalFieldType<TypeFromFields<{
                endSystime: ...;
                endTimestamp: ...;
                energy: ...;
                startSystime: ...;
                startTimestamp: ...;
            }>>;
            energyImported: OptionalFieldType<TypeFromFields<{
                endSystime: ...;
                endTimestamp: ...;
                energy: ...;
                startSystime: ...;
                startTimestamp: ...;
            }>>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                periodicEnergy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    features: {
        cumulativeEnergy: BitFlag;
        exportedEnergy: BitFlag;
        importedEnergy: BitFlag;
        periodicEnergy: BitFlag;
    };
    id: 145;
    name: "ElectricalEnergyMeasurement";
    revision: 1;
}>, AlterationsT>
Modify elements using ElementModifier.alter.
Type Parameters
- const AlterationsT extends Alterations<Of<{
      attributes: {
          accuracy: FixedAttribute<TypeFromFields<{
              accuracyRanges: FieldType<TypeFromFields<{
                  fixedMax: ...;
                  fixedMin: ...;
                  fixedTypical: ...;
                  percentMax: ...;
                  percentMin: ...;
                  percentTypical: ...;
                  rangeMax: ...;
                  rangeMin: ...;
              }>[]>;
              maxMeasuredValue: FieldType<number | bigint>;
              measured: FieldType<boolean>;
              measurementType: FieldType<MeasurementType>;
              minMeasuredValue: FieldType<number | bigint>;
          }>, any>;
          cumulativeEnergyExported: Attribute<null | TypeFromFields<{
              endSystime: OptionalFieldType<(...) | (...)>;
              endTimestamp: OptionalFieldType<number>;
              energy: FieldType<(...) | (...)>;
              startSystime: OptionalFieldType<(...) | (...)>;
              startTimestamp: OptionalFieldType<number>;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  cumulativeEnergy: boolean;
                  exportedEnergy: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          cumulativeEnergyImported: Attribute<null | TypeFromFields<{
              endSystime: OptionalFieldType<(...) | (...)>;
              endTimestamp: OptionalFieldType<number>;
              energy: FieldType<(...) | (...)>;
              startSystime: OptionalFieldType<(...) | (...)>;
              startTimestamp: OptionalFieldType<number>;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  cumulativeEnergy: boolean;
                  importedEnergy: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          cumulativeEnergyReset: OptionalAttribute<null | TypeFromFields<{
              exportedResetSystime: OptionalFieldType<(...) | (...) | (...)>;
              exportedResetTimestamp: OptionalFieldType<(...) | (...)>;
              importedResetSystime: OptionalFieldType<(...) | (...) | (...)>;
              importedResetTimestamp: OptionalFieldType<(...) | (...)>;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  cumulativeEnergy: boolean;
              }];
          };
          periodicEnergyExported: Attribute<null | TypeFromFields<{
              endSystime: OptionalFieldType<(...) | (...)>;
              endTimestamp: OptionalFieldType<number>;
              energy: FieldType<(...) | (...)>;
              startSystime: OptionalFieldType<(...) | (...)>;
              startTimestamp: OptionalFieldType<number>;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  exportedEnergy: boolean;
                  periodicEnergy: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          periodicEnergyImported: Attribute<null | TypeFromFields<{
              endSystime: OptionalFieldType<(...) | (...)>;
              endTimestamp: OptionalFieldType<number>;
              energy: FieldType<(...) | (...)>;
              startSystime: OptionalFieldType<(...) | (...)>;
              startTimestamp: OptionalFieldType<number>;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  importedEnergy: boolean;
                  periodicEnergy: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
      };
      events: {
          cumulativeEnergyMeasured: Event<TypeFromFields<{
              energyExported: OptionalFieldType<TypeFromFields<{
                  endSystime: ...;
                  endTimestamp: ...;
                  energy: ...;
                  startSystime: ...;
                  startTimestamp: ...;
              }>>;
              energyImported: OptionalFieldType<TypeFromFields<{
                  endSystime: ...;
                  endTimestamp: ...;
                  energy: ...;
                  startSystime: ...;
                  startTimestamp: ...;
              }>>;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  cumulativeEnergy: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          periodicEnergyMeasured: Event<TypeFromFields<{
              energyExported: OptionalFieldType<TypeFromFields<{
                  endSystime: ...;
                  endTimestamp: ...;
                  energy: ...;
                  startSystime: ...;
                  startTimestamp: ...;
              }>>;
              energyImported: OptionalFieldType<TypeFromFields<{
                  endSystime: ...;
                  endTimestamp: ...;
                  energy: ...;
                  startSystime: ...;
                  startTimestamp: ...;
              }>>;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  periodicEnergy: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
      };
      features: {
          cumulativeEnergy: BitFlag;
          exportedEnergy: BitFlag;
          importedEnergy: BitFlag;
          periodicEnergy: BitFlag;
      };
      id: 145;
      name: "ElectricalEnergyMeasurement";
      revision: 1;
  }>>
Parameters
- alterations: AlterationsT
Returns WithAlterations<Of<{
    attributes: {
        accuracy: FixedAttribute<TypeFromFields<{
            accuracyRanges: FieldType<TypeFromFields<{
                fixedMax: ...;
                fixedMin: ...;
                fixedTypical: ...;
                percentMax: ...;
                percentMin: ...;
                percentTypical: ...;
                rangeMax: ...;
                rangeMin: ...;
            }>[]>;
            maxMeasuredValue: FieldType<number | bigint>;
            measured: FieldType<boolean>;
            measurementType: FieldType<MeasurementType>;
            minMeasuredValue: FieldType<number | bigint>;
        }>, any>;
        cumulativeEnergyExported: Attribute<null | TypeFromFields<{
            endSystime: OptionalFieldType<(...) | (...)>;
            endTimestamp: OptionalFieldType<number>;
            energy: FieldType<(...) | (...)>;
            startSystime: OptionalFieldType<(...) | (...)>;
            startTimestamp: OptionalFieldType<number>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                cumulativeEnergy: boolean;
                exportedEnergy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        cumulativeEnergyImported: Attribute<null | TypeFromFields<{
            endSystime: OptionalFieldType<(...) | (...)>;
            endTimestamp: OptionalFieldType<number>;
            energy: FieldType<(...) | (...)>;
            startSystime: OptionalFieldType<(...) | (...)>;
            startTimestamp: OptionalFieldType<number>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                cumulativeEnergy: boolean;
                importedEnergy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        cumulativeEnergyReset: OptionalAttribute<null | TypeFromFields<{
            exportedResetSystime: OptionalFieldType<(...) | (...) | (...)>;
            exportedResetTimestamp: OptionalFieldType<(...) | (...)>;
            importedResetSystime: OptionalFieldType<(...) | (...) | (...)>;
            importedResetTimestamp: OptionalFieldType<(...) | (...)>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                cumulativeEnergy: boolean;
            }];
        };
        periodicEnergyExported: Attribute<null | TypeFromFields<{
            endSystime: OptionalFieldType<(...) | (...)>;
            endTimestamp: OptionalFieldType<number>;
            energy: FieldType<(...) | (...)>;
            startSystime: OptionalFieldType<(...) | (...)>;
            startTimestamp: OptionalFieldType<number>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                exportedEnergy: boolean;
                periodicEnergy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        periodicEnergyImported: Attribute<null | TypeFromFields<{
            endSystime: OptionalFieldType<(...) | (...)>;
            endTimestamp: OptionalFieldType<number>;
            energy: FieldType<(...) | (...)>;
            startSystime: OptionalFieldType<(...) | (...)>;
            startTimestamp: OptionalFieldType<number>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                importedEnergy: boolean;
                periodicEnergy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    events: {
        cumulativeEnergyMeasured: Event<TypeFromFields<{
            energyExported: OptionalFieldType<TypeFromFields<{
                endSystime: ...;
                endTimestamp: ...;
                energy: ...;
                startSystime: ...;
                startTimestamp: ...;
            }>>;
            energyImported: OptionalFieldType<TypeFromFields<{
                endSystime: ...;
                endTimestamp: ...;
                energy: ...;
                startSystime: ...;
                startTimestamp: ...;
            }>>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                cumulativeEnergy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        periodicEnergyMeasured: Event<TypeFromFields<{
            energyExported: OptionalFieldType<TypeFromFields<{
                endSystime: ...;
                endTimestamp: ...;
                energy: ...;
                startSystime: ...;
                startTimestamp: ...;
            }>>;
            energyImported: OptionalFieldType<TypeFromFields<{
                endSystime: ...;
                endTimestamp: ...;
                energy: ...;
                startSystime: ...;
                startTimestamp: ...;
            }>>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                periodicEnergy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    features: {
        cumulativeEnergy: BitFlag;
        exportedEnergy: BitFlag;
        importedEnergy: BitFlag;
        periodicEnergy: BitFlag;
    };
    id: 145;
    name: "ElectricalEnergyMeasurement";
    revision: 1;
}>, AlterationsT>
Inherited from Identity.alter
- Defined in packages/types/dist/esm/cluster/mutation/MutableCluster.d.ts:37

enable

enable<const FlagsT>(flags): WithFlags<Of<{
    attributes: {
        accuracy: FixedAttribute<TypeFromFields<{
            accuracyRanges: FieldType<TypeFromFields<{
                fixedMax: ...;
                fixedMin: ...;
                fixedTypical: ...;
                percentMax: ...;
                percentMin: ...;
                percentTypical: ...;
                rangeMax: ...;
                rangeMin: ...;
            }>[]>;
            maxMeasuredValue: FieldType<number | bigint>;
            measured: FieldType<boolean>;
            measurementType: FieldType<MeasurementType>;
            minMeasuredValue: FieldType<number | bigint>;
        }>, any>;
        cumulativeEnergyExported: Attribute<null | TypeFromFields<{
            endSystime: OptionalFieldType<(...) | (...)>;
            endTimestamp: OptionalFieldType<number>;
            energy: FieldType<(...) | (...)>;
            startSystime: OptionalFieldType<(...) | (...)>;
            startTimestamp: OptionalFieldType<number>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                cumulativeEnergy: boolean;
                exportedEnergy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        cumulativeEnergyImported: Attribute<null | TypeFromFields<{
            endSystime: OptionalFieldType<(...) | (...)>;
            endTimestamp: OptionalFieldType<number>;
            energy: FieldType<(...) | (...)>;
            startSystime: OptionalFieldType<(...) | (...)>;
            startTimestamp: OptionalFieldType<number>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                cumulativeEnergy: boolean;
                importedEnergy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        cumulativeEnergyReset: OptionalAttribute<null | TypeFromFields<{
            exportedResetSystime: OptionalFieldType<(...) | (...) | (...)>;
            exportedResetTimestamp: OptionalFieldType<(...) | (...)>;
            importedResetSystime: OptionalFieldType<(...) | (...) | (...)>;
            importedResetTimestamp: OptionalFieldType<(...) | (...)>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                cumulativeEnergy: boolean;
            }];
        };
        periodicEnergyExported: Attribute<null | TypeFromFields<{
            endSystime: OptionalFieldType<(...) | (...)>;
            endTimestamp: OptionalFieldType<number>;
            energy: FieldType<(...) | (...)>;
            startSystime: OptionalFieldType<(...) | (...)>;
            startTimestamp: OptionalFieldType<number>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                exportedEnergy: boolean;
                periodicEnergy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        periodicEnergyImported: Attribute<null | TypeFromFields<{
            endSystime: OptionalFieldType<(...) | (...)>;
            endTimestamp: OptionalFieldType<number>;
            energy: FieldType<(...) | (...)>;
            startSystime: OptionalFieldType<(...) | (...)>;
            startTimestamp: OptionalFieldType<number>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                importedEnergy: boolean;
                periodicEnergy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    events: {
        cumulativeEnergyMeasured: Event<TypeFromFields<{
            energyExported: OptionalFieldType<TypeFromFields<{
                endSystime: ...;
                endTimestamp: ...;
                energy: ...;
                startSystime: ...;
                startTimestamp: ...;
            }>>;
            energyImported: OptionalFieldType<TypeFromFields<{
                endSystime: ...;
                endTimestamp: ...;
                energy: ...;
                startSystime: ...;
                startTimestamp: ...;
            }>>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                cumulativeEnergy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        periodicEnergyMeasured: Event<TypeFromFields<{
            energyExported: OptionalFieldType<TypeFromFields<{
                endSystime: ...;
                endTimestamp: ...;
                energy: ...;
                startSystime: ...;
                startTimestamp: ...;
            }>>;
            energyImported: OptionalFieldType<TypeFromFields<{
                endSystime: ...;
                endTimestamp: ...;
                energy: ...;
                startSystime: ...;
                startTimestamp: ...;
            }>>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                periodicEnergy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    features: {
        cumulativeEnergy: BitFlag;
        exportedEnergy: BitFlag;
        importedEnergy: BitFlag;
        periodicEnergy: BitFlag;
    };
    id: 145;
    name: "ElectricalEnergyMeasurement";
    revision: 1;
}>, FlagsT>
Modify elements using ElementModifier.enable.
Type Parameters
- const FlagsT extends ElementFlags<Of<{
      attributes: {
          accuracy: FixedAttribute<TypeFromFields<{
              accuracyRanges: FieldType<TypeFromFields<{
                  fixedMax: ...;
                  fixedMin: ...;
                  fixedTypical: ...;
                  percentMax: ...;
                  percentMin: ...;
                  percentTypical: ...;
                  rangeMax: ...;
                  rangeMin: ...;
              }>[]>;
              maxMeasuredValue: FieldType<number | bigint>;
              measured: FieldType<boolean>;
              measurementType: FieldType<MeasurementType>;
              minMeasuredValue: FieldType<number | bigint>;
          }>, any>;
          cumulativeEnergyExported: Attribute<null | TypeFromFields<{
              endSystime: OptionalFieldType<(...) | (...)>;
              endTimestamp: OptionalFieldType<number>;
              energy: FieldType<(...) | (...)>;
              startSystime: OptionalFieldType<(...) | (...)>;
              startTimestamp: OptionalFieldType<number>;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  cumulativeEnergy: boolean;
                  exportedEnergy: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          cumulativeEnergyImported: Attribute<null | TypeFromFields<{
              endSystime: OptionalFieldType<(...) | (...)>;
              endTimestamp: OptionalFieldType<number>;
              energy: FieldType<(...) | (...)>;
              startSystime: OptionalFieldType<(...) | (...)>;
              startTimestamp: OptionalFieldType<number>;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  cumulativeEnergy: boolean;
                  importedEnergy: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          cumulativeEnergyReset: OptionalAttribute<null | TypeFromFields<{
              exportedResetSystime: OptionalFieldType<(...) | (...) | (...)>;
              exportedResetTimestamp: OptionalFieldType<(...) | (...)>;
              importedResetSystime: OptionalFieldType<(...) | (...) | (...)>;
              importedResetTimestamp: OptionalFieldType<(...) | (...)>;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  cumulativeEnergy: boolean;
              }];
          };
          periodicEnergyExported: Attribute<null | TypeFromFields<{
              endSystime: OptionalFieldType<(...) | (...)>;
              endTimestamp: OptionalFieldType<number>;
              energy: FieldType<(...) | (...)>;
              startSystime: OptionalFieldType<(...) | (...)>;
              startTimestamp: OptionalFieldType<number>;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  exportedEnergy: boolean;
                  periodicEnergy: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          periodicEnergyImported: Attribute<null | TypeFromFields<{
              endSystime: OptionalFieldType<(...) | (...)>;
              endTimestamp: OptionalFieldType<number>;
              energy: FieldType<(...) | (...)>;
              startSystime: OptionalFieldType<(...) | (...)>;
              startTimestamp: OptionalFieldType<number>;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  importedEnergy: boolean;
                  periodicEnergy: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
      };
      events: {
          cumulativeEnergyMeasured: Event<TypeFromFields<{
              energyExported: OptionalFieldType<TypeFromFields<{
                  endSystime: ...;
                  endTimestamp: ...;
                  energy: ...;
                  startSystime: ...;
                  startTimestamp: ...;
              }>>;
              energyImported: OptionalFieldType<TypeFromFields<{
                  endSystime: ...;
                  endTimestamp: ...;
                  energy: ...;
                  startSystime: ...;
                  startTimestamp: ...;
              }>>;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  cumulativeEnergy: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          periodicEnergyMeasured: Event<TypeFromFields<{
              energyExported: OptionalFieldType<TypeFromFields<{
                  endSystime: ...;
                  endTimestamp: ...;
                  energy: ...;
                  startSystime: ...;
                  startTimestamp: ...;
              }>>;
              energyImported: OptionalFieldType<TypeFromFields<{
                  endSystime: ...;
                  endTimestamp: ...;
                  energy: ...;
                  startSystime: ...;
                  startTimestamp: ...;
              }>>;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  periodicEnergy: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
      };
      features: {
          cumulativeEnergy: BitFlag;
          exportedEnergy: BitFlag;
          importedEnergy: BitFlag;
          periodicEnergy: BitFlag;
      };
      id: 145;
      name: "ElectricalEnergyMeasurement";
      revision: 1;
  }>>
Parameters
- flags: FlagsT
Returns WithFlags<Of<{
    attributes: {
        accuracy: FixedAttribute<TypeFromFields<{
            accuracyRanges: FieldType<TypeFromFields<{
                fixedMax: ...;
                fixedMin: ...;
                fixedTypical: ...;
                percentMax: ...;
                percentMin: ...;
                percentTypical: ...;
                rangeMax: ...;
                rangeMin: ...;
            }>[]>;
            maxMeasuredValue: FieldType<number | bigint>;
            measured: FieldType<boolean>;
            measurementType: FieldType<MeasurementType>;
            minMeasuredValue: FieldType<number | bigint>;
        }>, any>;
        cumulativeEnergyExported: Attribute<null | TypeFromFields<{
            endSystime: OptionalFieldType<(...) | (...)>;
            endTimestamp: OptionalFieldType<number>;
            energy: FieldType<(...) | (...)>;
            startSystime: OptionalFieldType<(...) | (...)>;
            startTimestamp: OptionalFieldType<number>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                cumulativeEnergy: boolean;
                exportedEnergy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        cumulativeEnergyImported: Attribute<null | TypeFromFields<{
            endSystime: OptionalFieldType<(...) | (...)>;
            endTimestamp: OptionalFieldType<number>;
            energy: FieldType<(...) | (...)>;
            startSystime: OptionalFieldType<(...) | (...)>;
            startTimestamp: OptionalFieldType<number>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                cumulativeEnergy: boolean;
                importedEnergy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        cumulativeEnergyReset: OptionalAttribute<null | TypeFromFields<{
            exportedResetSystime: OptionalFieldType<(...) | (...) | (...)>;
            exportedResetTimestamp: OptionalFieldType<(...) | (...)>;
            importedResetSystime: OptionalFieldType<(...) | (...) | (...)>;
            importedResetTimestamp: OptionalFieldType<(...) | (...)>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                cumulativeEnergy: boolean;
            }];
        };
        periodicEnergyExported: Attribute<null | TypeFromFields<{
            endSystime: OptionalFieldType<(...) | (...)>;
            endTimestamp: OptionalFieldType<number>;
            energy: FieldType<(...) | (...)>;
            startSystime: OptionalFieldType<(...) | (...)>;
            startTimestamp: OptionalFieldType<number>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                exportedEnergy: boolean;
                periodicEnergy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        periodicEnergyImported: Attribute<null | TypeFromFields<{
            endSystime: OptionalFieldType<(...) | (...)>;
            endTimestamp: OptionalFieldType<number>;
            energy: FieldType<(...) | (...)>;
            startSystime: OptionalFieldType<(...) | (...)>;
            startTimestamp: OptionalFieldType<number>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                importedEnergy: boolean;
                periodicEnergy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    events: {
        cumulativeEnergyMeasured: Event<TypeFromFields<{
            energyExported: OptionalFieldType<TypeFromFields<{
                endSystime: ...;
                endTimestamp: ...;
                energy: ...;
                startSystime: ...;
                startTimestamp: ...;
            }>>;
            energyImported: OptionalFieldType<TypeFromFields<{
                endSystime: ...;
                endTimestamp: ...;
                energy: ...;
                startSystime: ...;
                startTimestamp: ...;
            }>>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                cumulativeEnergy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        periodicEnergyMeasured: Event<TypeFromFields<{
            energyExported: OptionalFieldType<TypeFromFields<{
                endSystime: ...;
                endTimestamp: ...;
                energy: ...;
                startSystime: ...;
                startTimestamp: ...;
            }>>;
            energyImported: OptionalFieldType<TypeFromFields<{
                endSystime: ...;
                endTimestamp: ...;
                energy: ...;
                startSystime: ...;
                startTimestamp: ...;
            }>>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                periodicEnergy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    features: {
        cumulativeEnergy: BitFlag;
        exportedEnergy: BitFlag;
        importedEnergy: BitFlag;
        periodicEnergy: BitFlag;
    };
    id: 145;
    name: "ElectricalEnergyMeasurement";
    revision: 1;
}>, FlagsT>
Inherited from Identity.enable
- Defined in packages/types/dist/esm/cluster/mutation/MutableCluster.d.ts:45

set

set<const ValuesT>(values): WithValues<Of<{
    attributes: {
        accuracy: FixedAttribute<TypeFromFields<{
            accuracyRanges: FieldType<TypeFromFields<{
                fixedMax: ...;
                fixedMin: ...;
                fixedTypical: ...;
                percentMax: ...;
                percentMin: ...;
                percentTypical: ...;
                rangeMax: ...;
                rangeMin: ...;
            }>[]>;
            maxMeasuredValue: FieldType<number | bigint>;
            measured: FieldType<boolean>;
            measurementType: FieldType<MeasurementType>;
            minMeasuredValue: FieldType<number | bigint>;
        }>, any>;
        cumulativeEnergyExported: Attribute<null | TypeFromFields<{
            endSystime: OptionalFieldType<(...) | (...)>;
            endTimestamp: OptionalFieldType<number>;
            energy: FieldType<(...) | (...)>;
            startSystime: OptionalFieldType<(...) | (...)>;
            startTimestamp: OptionalFieldType<number>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                cumulativeEnergy: boolean;
                exportedEnergy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        cumulativeEnergyImported: Attribute<null | TypeFromFields<{
            endSystime: OptionalFieldType<(...) | (...)>;
            endTimestamp: OptionalFieldType<number>;
            energy: FieldType<(...) | (...)>;
            startSystime: OptionalFieldType<(...) | (...)>;
            startTimestamp: OptionalFieldType<number>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                cumulativeEnergy: boolean;
                importedEnergy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        cumulativeEnergyReset: OptionalAttribute<null | TypeFromFields<{
            exportedResetSystime: OptionalFieldType<(...) | (...) | (...)>;
            exportedResetTimestamp: OptionalFieldType<(...) | (...)>;
            importedResetSystime: OptionalFieldType<(...) | (...) | (...)>;
            importedResetTimestamp: OptionalFieldType<(...) | (...)>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                cumulativeEnergy: boolean;
            }];
        };
        periodicEnergyExported: Attribute<null | TypeFromFields<{
            endSystime: OptionalFieldType<(...) | (...)>;
            endTimestamp: OptionalFieldType<number>;
            energy: FieldType<(...) | (...)>;
            startSystime: OptionalFieldType<(...) | (...)>;
            startTimestamp: OptionalFieldType<number>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                exportedEnergy: boolean;
                periodicEnergy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        periodicEnergyImported: Attribute<null | TypeFromFields<{
            endSystime: OptionalFieldType<(...) | (...)>;
            endTimestamp: OptionalFieldType<number>;
            energy: FieldType<(...) | (...)>;
            startSystime: OptionalFieldType<(...) | (...)>;
            startTimestamp: OptionalFieldType<number>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                importedEnergy: boolean;
                periodicEnergy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    events: {
        cumulativeEnergyMeasured: Event<TypeFromFields<{
            energyExported: OptionalFieldType<TypeFromFields<{
                endSystime: ...;
                endTimestamp: ...;
                energy: ...;
                startSystime: ...;
                startTimestamp: ...;
            }>>;
            energyImported: OptionalFieldType<TypeFromFields<{
                endSystime: ...;
                endTimestamp: ...;
                energy: ...;
                startSystime: ...;
                startTimestamp: ...;
            }>>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                cumulativeEnergy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        periodicEnergyMeasured: Event<TypeFromFields<{
            energyExported: OptionalFieldType<TypeFromFields<{
                endSystime: ...;
                endTimestamp: ...;
                energy: ...;
                startSystime: ...;
                startTimestamp: ...;
            }>>;
            energyImported: OptionalFieldType<TypeFromFields<{
                endSystime: ...;
                endTimestamp: ...;
                energy: ...;
                startSystime: ...;
                startTimestamp: ...;
            }>>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                periodicEnergy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    features: {
        cumulativeEnergy: BitFlag;
        exportedEnergy: BitFlag;
        importedEnergy: BitFlag;
        periodicEnergy: BitFlag;
    };
    id: 145;
    name: "ElectricalEnergyMeasurement";
    revision: 1;
}>, ValuesT>
Modify elements using ElementModifier.set.
Type Parameters
- const ValuesT extends {
      accuracy: {
          accuracyRanges: {
              fixedMax?: number | bigint;
              fixedMin?: number | bigint;
              fixedTypical?: number | bigint;
              percentMax?: number;
              percentMin?: number;
              percentTypical?: number;
              rangeMax: number | bigint;
              rangeMin: number | bigint;
          }[];
          maxMeasuredValue: number | bigint;
          measured: boolean;
          measurementType: number;
          minMeasuredValue: number | bigint;
      };
      cumulativeEnergyExported?: null | {
          endSystime?: number | bigint;
          endTimestamp?: number;
          energy: number | bigint;
          startSystime?: number | bigint;
          startTimestamp?: number;
      };
      cumulativeEnergyImported?: null | {
          endSystime?: number | bigint;
          endTimestamp?: number;
          energy: number | bigint;
          startSystime?: number | bigint;
          startTimestamp?: number;
      };
      cumulativeEnergyReset?: null | {
          exportedResetSystime?: null | number | bigint;
          exportedResetTimestamp?: null | number;
          importedResetSystime?: null | number | bigint;
          importedResetTimestamp?: null | number;
      };
      periodicEnergyExported?: null | {
          endSystime?: number | bigint;
          endTimestamp?: number;
          energy: number | bigint;
          startSystime?: number | bigint;
          startTimestamp?: number;
      };
      periodicEnergyImported?: null | {
          endSystime?: number | bigint;
          endTimestamp?: number;
          energy: number | bigint;
          startSystime?: number | bigint;
          startTimestamp?: number;
      };
  }
Parameters
- values: ValuesT
Returns WithValues<Of<{
    attributes: {
        accuracy: FixedAttribute<TypeFromFields<{
            accuracyRanges: FieldType<TypeFromFields<{
                fixedMax: ...;
                fixedMin: ...;
                fixedTypical: ...;
                percentMax: ...;
                percentMin: ...;
                percentTypical: ...;
                rangeMax: ...;
                rangeMin: ...;
            }>[]>;
            maxMeasuredValue: FieldType<number | bigint>;
            measured: FieldType<boolean>;
            measurementType: FieldType<MeasurementType>;
            minMeasuredValue: FieldType<number | bigint>;
        }>, any>;
        cumulativeEnergyExported: Attribute<null | TypeFromFields<{
            endSystime: OptionalFieldType<(...) | (...)>;
            endTimestamp: OptionalFieldType<number>;
            energy: FieldType<(...) | (...)>;
            startSystime: OptionalFieldType<(...) | (...)>;
            startTimestamp: OptionalFieldType<number>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                cumulativeEnergy: boolean;
                exportedEnergy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        cumulativeEnergyImported: Attribute<null | TypeFromFields<{
            endSystime: OptionalFieldType<(...) | (...)>;
            endTimestamp: OptionalFieldType<number>;
            energy: FieldType<(...) | (...)>;
            startSystime: OptionalFieldType<(...) | (...)>;
            startTimestamp: OptionalFieldType<number>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                cumulativeEnergy: boolean;
                importedEnergy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        cumulativeEnergyReset: OptionalAttribute<null | TypeFromFields<{
            exportedResetSystime: OptionalFieldType<(...) | (...) | (...)>;
            exportedResetTimestamp: OptionalFieldType<(...) | (...)>;
            importedResetSystime: OptionalFieldType<(...) | (...) | (...)>;
            importedResetTimestamp: OptionalFieldType<(...) | (...)>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                cumulativeEnergy: boolean;
            }];
        };
        periodicEnergyExported: Attribute<null | TypeFromFields<{
            endSystime: OptionalFieldType<(...) | (...)>;
            endTimestamp: OptionalFieldType<number>;
            energy: FieldType<(...) | (...)>;
            startSystime: OptionalFieldType<(...) | (...)>;
            startTimestamp: OptionalFieldType<number>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                exportedEnergy: boolean;
                periodicEnergy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        periodicEnergyImported: Attribute<null | TypeFromFields<{
            endSystime: OptionalFieldType<(...) | (...)>;
            endTimestamp: OptionalFieldType<number>;
            energy: FieldType<(...) | (...)>;
            startSystime: OptionalFieldType<(...) | (...)>;
            startTimestamp: OptionalFieldType<number>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                importedEnergy: boolean;
                periodicEnergy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    events: {
        cumulativeEnergyMeasured: Event<TypeFromFields<{
            energyExported: OptionalFieldType<TypeFromFields<{
                endSystime: ...;
                endTimestamp: ...;
                energy: ...;
                startSystime: ...;
                startTimestamp: ...;
            }>>;
            energyImported: OptionalFieldType<TypeFromFields<{
                endSystime: ...;
                endTimestamp: ...;
                energy: ...;
                startSystime: ...;
                startTimestamp: ...;
            }>>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                cumulativeEnergy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        periodicEnergyMeasured: Event<TypeFromFields<{
            energyExported: OptionalFieldType<TypeFromFields<{
                endSystime: ...;
                endTimestamp: ...;
                energy: ...;
                startSystime: ...;
                startTimestamp: ...;
            }>>;
            energyImported: OptionalFieldType<TypeFromFields<{
                endSystime: ...;
                endTimestamp: ...;
                energy: ...;
                startSystime: ...;
                startTimestamp: ...;
            }>>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                periodicEnergy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    features: {
        cumulativeEnergy: BitFlag;
        exportedEnergy: BitFlag;
        importedEnergy: BitFlag;
        periodicEnergy: BitFlag;
    };
    id: 145;
    name: "ElectricalEnergyMeasurement";
    revision: 1;
}>, ValuesT>
Inherited from Identity.set
- Defined in packages/types/dist/esm/cluster/mutation/MutableCluster.d.ts:41

with

with<const SelectionT>(...selection): Of<Of<{
    attributes: {
        accuracy: FixedAttribute<TypeFromFields<{
            accuracyRanges: FieldType<TypeFromFields<{
                fixedMax: ...;
                fixedMin: ...;
                fixedTypical: ...;
                percentMax: ...;
                percentMin: ...;
                percentTypical: ...;
                rangeMax: ...;
                rangeMin: ...;
            }>[]>;
            maxMeasuredValue: FieldType<number | bigint>;
            measured: FieldType<boolean>;
            measurementType: FieldType<MeasurementType>;
            minMeasuredValue: FieldType<number | bigint>;
        }>, any>;
        cumulativeEnergyExported: Attribute<null | TypeFromFields<{
            endSystime: OptionalFieldType<(...) | (...)>;
            endTimestamp: OptionalFieldType<number>;
            energy: FieldType<(...) | (...)>;
            startSystime: OptionalFieldType<(...) | (...)>;
            startTimestamp: OptionalFieldType<number>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                cumulativeEnergy: boolean;
                exportedEnergy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        cumulativeEnergyImported: Attribute<null | TypeFromFields<{
            endSystime: OptionalFieldType<(...) | (...)>;
            endTimestamp: OptionalFieldType<number>;
            energy: FieldType<(...) | (...)>;
            startSystime: OptionalFieldType<(...) | (...)>;
            startTimestamp: OptionalFieldType<number>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                cumulativeEnergy: boolean;
                importedEnergy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        cumulativeEnergyReset: OptionalAttribute<null | TypeFromFields<{
            exportedResetSystime: OptionalFieldType<(...) | (...) | (...)>;
            exportedResetTimestamp: OptionalFieldType<(...) | (...)>;
            importedResetSystime: OptionalFieldType<(...) | (...) | (...)>;
            importedResetTimestamp: OptionalFieldType<(...) | (...)>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                cumulativeEnergy: boolean;
            }];
        };
        periodicEnergyExported: Attribute<null | TypeFromFields<{
            endSystime: OptionalFieldType<(...) | (...)>;
            endTimestamp: OptionalFieldType<number>;
            energy: FieldType<(...) | (...)>;
            startSystime: OptionalFieldType<(...) | (...)>;
            startTimestamp: OptionalFieldType<number>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                exportedEnergy: boolean;
                periodicEnergy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        periodicEnergyImported: Attribute<null | TypeFromFields<{
            endSystime: OptionalFieldType<(...) | (...)>;
            endTimestamp: OptionalFieldType<number>;
            energy: FieldType<(...) | (...)>;
            startSystime: OptionalFieldType<(...) | (...)>;
            startTimestamp: OptionalFieldType<number>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                importedEnergy: boolean;
                periodicEnergy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    events: {
        cumulativeEnergyMeasured: Event<TypeFromFields<{
            energyExported: OptionalFieldType<TypeFromFields<{
                endSystime: ...;
                endTimestamp: ...;
                energy: ...;
                startSystime: ...;
                startTimestamp: ...;
            }>>;
            energyImported: OptionalFieldType<TypeFromFields<{
                endSystime: ...;
                endTimestamp: ...;
                energy: ...;
                startSystime: ...;
                startTimestamp: ...;
            }>>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                cumulativeEnergy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        periodicEnergyMeasured: Event<TypeFromFields<{
            energyExported: OptionalFieldType<TypeFromFields<{
                endSystime: ...;
                endTimestamp: ...;
                energy: ...;
                startSystime: ...;
                startTimestamp: ...;
            }>>;
            energyImported: OptionalFieldType<TypeFromFields<{
                endSystime: ...;
                endTimestamp: ...;
                energy: ...;
                startSystime: ...;
                startTimestamp: ...;
            }>>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                periodicEnergy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    features: {
        cumulativeEnergy: BitFlag;
        exportedEnergy: BitFlag;
        importedEnergy: BitFlag;
        periodicEnergy: BitFlag;
    };
    id: 145;
    name: "ElectricalEnergyMeasurement";
    revision: 1;
}>, SelectionT>
Select features using ClusterComposer.compose.
Type Parameters
- const SelectionT extends FeatureSelection<Of<{
      attributes: {
          accuracy: FixedAttribute<TypeFromFields<{
              accuracyRanges: FieldType<TypeFromFields<{
                  fixedMax: ...;
                  fixedMin: ...;
                  fixedTypical: ...;
                  percentMax: ...;
                  percentMin: ...;
                  percentTypical: ...;
                  rangeMax: ...;
                  rangeMin: ...;
              }>[]>;
              maxMeasuredValue: FieldType<number | bigint>;
              measured: FieldType<boolean>;
              measurementType: FieldType<MeasurementType>;
              minMeasuredValue: FieldType<number | bigint>;
          }>, any>;
          cumulativeEnergyExported: Attribute<null | TypeFromFields<{
              endSystime: OptionalFieldType<(...) | (...)>;
              endTimestamp: OptionalFieldType<number>;
              energy: FieldType<(...) | (...)>;
              startSystime: OptionalFieldType<(...) | (...)>;
              startTimestamp: OptionalFieldType<number>;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  cumulativeEnergy: boolean;
                  exportedEnergy: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          cumulativeEnergyImported: Attribute<null | TypeFromFields<{
              endSystime: OptionalFieldType<(...) | (...)>;
              endTimestamp: OptionalFieldType<number>;
              energy: FieldType<(...) | (...)>;
              startSystime: OptionalFieldType<(...) | (...)>;
              startTimestamp: OptionalFieldType<number>;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  cumulativeEnergy: boolean;
                  importedEnergy: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          cumulativeEnergyReset: OptionalAttribute<null | TypeFromFields<{
              exportedResetSystime: OptionalFieldType<(...) | (...) | (...)>;
              exportedResetTimestamp: OptionalFieldType<(...) | (...)>;
              importedResetSystime: OptionalFieldType<(...) | (...) | (...)>;
              importedResetTimestamp: OptionalFieldType<(...) | (...)>;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  cumulativeEnergy: boolean;
              }];
          };
          periodicEnergyExported: Attribute<null | TypeFromFields<{
              endSystime: OptionalFieldType<(...) | (...)>;
              endTimestamp: OptionalFieldType<number>;
              energy: FieldType<(...) | (...)>;
              startSystime: OptionalFieldType<(...) | (...)>;
              startTimestamp: OptionalFieldType<number>;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  exportedEnergy: boolean;
                  periodicEnergy: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          periodicEnergyImported: Attribute<null | TypeFromFields<{
              endSystime: OptionalFieldType<(...) | (...)>;
              endTimestamp: OptionalFieldType<number>;
              energy: FieldType<(...) | (...)>;
              startSystime: OptionalFieldType<(...) | (...)>;
              startTimestamp: OptionalFieldType<number>;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  importedEnergy: boolean;
                  periodicEnergy: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
      };
      events: {
          cumulativeEnergyMeasured: Event<TypeFromFields<{
              energyExported: OptionalFieldType<TypeFromFields<{
                  endSystime: ...;
                  endTimestamp: ...;
                  energy: ...;
                  startSystime: ...;
                  startTimestamp: ...;
              }>>;
              energyImported: OptionalFieldType<TypeFromFields<{
                  endSystime: ...;
                  endTimestamp: ...;
                  energy: ...;
                  startSystime: ...;
                  startTimestamp: ...;
              }>>;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  cumulativeEnergy: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          periodicEnergyMeasured: Event<TypeFromFields<{
              energyExported: OptionalFieldType<TypeFromFields<{
                  endSystime: ...;
                  endTimestamp: ...;
                  energy: ...;
                  startSystime: ...;
                  startTimestamp: ...;
              }>>;
              energyImported: OptionalFieldType<TypeFromFields<{
                  endSystime: ...;
                  endTimestamp: ...;
                  energy: ...;
                  startSystime: ...;
                  startTimestamp: ...;
              }>>;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  periodicEnergy: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
      };
      features: {
          cumulativeEnergy: BitFlag;
          exportedEnergy: BitFlag;
          importedEnergy: BitFlag;
          periodicEnergy: BitFlag;
      };
      id: 145;
      name: "ElectricalEnergyMeasurement";
      revision: 1;
  }>>
Parameters
- Rest...selection: SelectionT
Returns Of<Of<{
    attributes: {
        accuracy: FixedAttribute<TypeFromFields<{
            accuracyRanges: FieldType<TypeFromFields<{
                fixedMax: ...;
                fixedMin: ...;
                fixedTypical: ...;
                percentMax: ...;
                percentMin: ...;
                percentTypical: ...;
                rangeMax: ...;
                rangeMin: ...;
            }>[]>;
            maxMeasuredValue: FieldType<number | bigint>;
            measured: FieldType<boolean>;
            measurementType: FieldType<MeasurementType>;
            minMeasuredValue: FieldType<number | bigint>;
        }>, any>;
        cumulativeEnergyExported: Attribute<null | TypeFromFields<{
            endSystime: OptionalFieldType<(...) | (...)>;
            endTimestamp: OptionalFieldType<number>;
            energy: FieldType<(...) | (...)>;
            startSystime: OptionalFieldType<(...) | (...)>;
            startTimestamp: OptionalFieldType<number>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                cumulativeEnergy: boolean;
                exportedEnergy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        cumulativeEnergyImported: Attribute<null | TypeFromFields<{
            endSystime: OptionalFieldType<(...) | (...)>;
            endTimestamp: OptionalFieldType<number>;
            energy: FieldType<(...) | (...)>;
            startSystime: OptionalFieldType<(...) | (...)>;
            startTimestamp: OptionalFieldType<number>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                cumulativeEnergy: boolean;
                importedEnergy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        cumulativeEnergyReset: OptionalAttribute<null | TypeFromFields<{
            exportedResetSystime: OptionalFieldType<(...) | (...) | (...)>;
            exportedResetTimestamp: OptionalFieldType<(...) | (...)>;
            importedResetSystime: OptionalFieldType<(...) | (...) | (...)>;
            importedResetTimestamp: OptionalFieldType<(...) | (...)>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                cumulativeEnergy: boolean;
            }];
        };
        periodicEnergyExported: Attribute<null | TypeFromFields<{
            endSystime: OptionalFieldType<(...) | (...)>;
            endTimestamp: OptionalFieldType<number>;
            energy: FieldType<(...) | (...)>;
            startSystime: OptionalFieldType<(...) | (...)>;
            startTimestamp: OptionalFieldType<number>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                exportedEnergy: boolean;
                periodicEnergy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        periodicEnergyImported: Attribute<null | TypeFromFields<{
            endSystime: OptionalFieldType<(...) | (...)>;
            endTimestamp: OptionalFieldType<number>;
            energy: FieldType<(...) | (...)>;
            startSystime: OptionalFieldType<(...) | (...)>;
            startTimestamp: OptionalFieldType<number>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                importedEnergy: boolean;
                periodicEnergy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    events: {
        cumulativeEnergyMeasured: Event<TypeFromFields<{
            energyExported: OptionalFieldType<TypeFromFields<{
                endSystime: ...;
                endTimestamp: ...;
                energy: ...;
                startSystime: ...;
                startTimestamp: ...;
            }>>;
            energyImported: OptionalFieldType<TypeFromFields<{
                endSystime: ...;
                endTimestamp: ...;
                energy: ...;
                startSystime: ...;
                startTimestamp: ...;
            }>>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                cumulativeEnergy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        periodicEnergyMeasured: Event<TypeFromFields<{
            energyExported: OptionalFieldType<TypeFromFields<{
                endSystime: ...;
                endTimestamp: ...;
                energy: ...;
                startSystime: ...;
                startTimestamp: ...;
            }>>;
            energyImported: OptionalFieldType<TypeFromFields<{
                endSystime: ...;
                endTimestamp: ...;
                energy: ...;
                startSystime: ...;
                startTimestamp: ...;
            }>>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                periodicEnergy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    features: {
        cumulativeEnergy: BitFlag;
        exportedEnergy: BitFlag;
        importedEnergy: BitFlag;
        periodicEnergy: BitFlag;
    };
    id: 145;
    name: "ElectricalEnergyMeasurement";
    revision: 1;
}>, SelectionT>
Inherited from Identity.with
- Defined in packages/types/dist/esm/cluster/mutation/MutableCluster.d.ts:33

Interface Complete

Hierarchy (view full)

Index

Properties

Methods

Properties

attributes

Type declaration

See

base

commands

events

extensions

features

Type declaration

ReadonlycumulativeEnergy: BitFlag

See

ReadonlyexportedEnergy: BitFlag

See

ReadonlyimportedEnergy: BitFlag

See

ReadonlyperiodicEnergy: BitFlag

See

id

name

revision

supportedFeatures

unknown

Methods

alter

Type Parameters

Parameters

enable

Type Parameters

Parameters

set

Type Parameters

Parameters

with

Type Parameters

Parameters

Settings

On This Page

`Readonly`cumulativeEnergy: BitFlag

`Readonly`exportedEnergy: BitFlag

`Readonly`importedEnergy: BitFlag

`Readonly`periodicEnergy: BitFlag