Interface Complete

This cluster supports all ElectricalPowerMeasurement 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<(...)>;
                percentMin: OptionalFieldType<(...)>;
                percentTypical: OptionalFieldType<(...)>;
                rangeMax: FieldType<(...)>;
                rangeMin: FieldType<(...)>;
            }>[]>;
            maxMeasuredValue: FieldType<number | bigint>;
            measured: FieldType<boolean>;
            measurementType: FieldType<MeasurementType>;
            minMeasuredValue: FieldType<number | bigint>;
        }>[], any>;
        activeCurrent: OptionalAttribute<null | number | bigint, any>;
        activePower: Attribute<null | number | bigint, any>;
        apparentCurrent: OptionalAttribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                alternatingCurrent: boolean;
            }];
        };
        apparentPower: OptionalAttribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                alternatingCurrent: boolean;
            }];
        };
        frequency: OptionalAttribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                alternatingCurrent: boolean;
            }];
        };
        harmonicCurrents: Attribute<null | TypeFromFields<{
            measurement: FieldType<null | number | bigint>;
            order: FieldType<number>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                harmonics: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        harmonicPhases: Attribute<null | TypeFromFields<{
            measurement: FieldType<null | number | bigint>;
            order: FieldType<number>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                powerQuality: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        neutralCurrent: OptionalAttribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                polyphasePower: boolean;
            }];
        };
        numberOfMeasurementTypes: FixedAttribute<number, any>;
        powerFactor: OptionalAttribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                alternatingCurrent: boolean;
            }];
        };
        powerMode: Attribute<ElectricalPowerMeasurement.PowerMode, any>;
        ranges: OptionalAttribute<TypeFromFields<{
            endSystime: OptionalFieldType<number | bigint>;
            endTimestamp: OptionalFieldType<number>;
            max: FieldType<number | bigint>;
            maxSystime: OptionalFieldType<number | bigint>;
            maxTimestamp: OptionalFieldType<number>;
            measurementType: FieldType<MeasurementType>;
            min: FieldType<number | bigint>;
            minSystime: OptionalFieldType<number | bigint>;
            minTimestamp: OptionalFieldType<number>;
            startSystime: OptionalFieldType<number | bigint>;
            startTimestamp: OptionalFieldType<number>;
        }>[], any>;
        reactiveCurrent: OptionalAttribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                alternatingCurrent: boolean;
            }];
        };
        reactivePower: OptionalAttribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                alternatingCurrent: boolean;
            }];
        };
        rmsCurrent: OptionalAttribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                alternatingCurrent: boolean;
            }];
        };
        rmsPower: OptionalAttribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                alternatingCurrent: boolean;
            }];
        };
        rmsVoltage: OptionalAttribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                alternatingCurrent: boolean;
            }];
        };
        voltage: OptionalAttribute<null | number | bigint, any>;
    }, GlobalAttributes<{
        alternatingCurrent: BitFlag;
        directCurrent: BitFlag;
        harmonics: BitFlag;
        polyphasePower: BitFlag;
        powerQuality: BitFlag;
    }>>;
    base: undefined;
    commands: {};
    events: {
        measurementPeriodRanges: OptionalEvent<TypeFromFields<{
            ranges: FieldType<TypeFromFields<{
                endSystime: OptionalFieldType<number | bigint>;
                endTimestamp: OptionalFieldType<number>;
                max: FieldType<number | bigint>;
                maxSystime: OptionalFieldType<number | bigint>;
                maxTimestamp: OptionalFieldType<number>;
                measurementType: FieldType<MeasurementType>;
                min: FieldType<number | bigint>;
                minSystime: OptionalFieldType<number | bigint>;
                minTimestamp: OptionalFieldType<number>;
                startSystime: OptionalFieldType<number | bigint>;
                startTimestamp: OptionalFieldType<number>;
            }>[]>;
        }>, any>;
    };
    extensions: undefined;
    features: {
        alternatingCurrent: BitFlag;
        directCurrent: BitFlag;
        harmonics: BitFlag;
        polyphasePower: BitFlag;
        powerQuality: BitFlag;
    };
    id: Branded<144, "ClusterId">;
    name: "ElectricalPowerMeasurement";
    revision: 1;
    supportedFeatures: {};
    unknown: false;
    alter<const AlterationsT>(alterations: AlterationsT): WithAlterations<Of<{
        attributes: {
            accuracy: FixedAttribute<TypeFromFields<{
                accuracyRanges: FieldType<TypeFromFields<(...)>[]>;
                maxMeasuredValue: FieldType<number | bigint>;
                measured: FieldType<boolean>;
                measurementType: FieldType<MeasurementType>;
                minMeasuredValue: FieldType<number | bigint>;
            }>[], any>;
            activeCurrent: OptionalAttribute<null | number | bigint, any>;
            activePower: Attribute<null | number | bigint, any>;
            apparentCurrent: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            apparentPower: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            frequency: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            harmonicCurrents: Attribute<null | TypeFromFields<{
                measurement: FieldType<(...)>;
                order: FieldType<(...)>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    harmonics: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            harmonicPhases: Attribute<null | TypeFromFields<{
                measurement: FieldType<(...)>;
                order: FieldType<(...)>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerQuality: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            neutralCurrent: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    polyphasePower: boolean;
                }];
            };
            numberOfMeasurementTypes: FixedAttribute<number, any>;
            powerFactor: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            powerMode: Attribute<ElectricalPowerMeasurement.PowerMode, any>;
            ranges: OptionalAttribute<TypeFromFields<{
                endSystime: OptionalFieldType<number | bigint>;
                endTimestamp: OptionalFieldType<number>;
                max: FieldType<number | bigint>;
                maxSystime: OptionalFieldType<number | bigint>;
                maxTimestamp: OptionalFieldType<number>;
                measurementType: FieldType<MeasurementType>;
                min: FieldType<number | bigint>;
                minSystime: OptionalFieldType<number | bigint>;
                minTimestamp: OptionalFieldType<number>;
                startSystime: OptionalFieldType<number | bigint>;
                startTimestamp: OptionalFieldType<number>;
            }>[], any>;
            reactiveCurrent: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            reactivePower: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            rmsCurrent: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            rmsPower: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            rmsVoltage: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            voltage: OptionalAttribute<null | number | bigint, any>;
        };
        events: {
            measurementPeriodRanges: OptionalEvent<TypeFromFields<{
                ranges: FieldType<TypeFromFields<{
                    endSystime: ...;
                    endTimestamp: ...;
                    max: ...;
                    maxSystime: ...;
                    maxTimestamp: ...;
                    measurementType: ...;
                    min: ...;
                    minSystime: ...;
                    minTimestamp: ...;
                    startSystime: ...;
                    startTimestamp: ...;
                }>[]>;
            }>, any>;
        };
        features: {
            alternatingCurrent: BitFlag;
            directCurrent: BitFlag;
            harmonics: BitFlag;
            polyphasePower: BitFlag;
            powerQuality: BitFlag;
        };
        id: 144;
        name: "ElectricalPowerMeasurement";
        revision: 1;
    }>, AlterationsT>;
    enable<const FlagsT>(flags: FlagsT): WithFlags<Of<{
        attributes: {
            accuracy: FixedAttribute<TypeFromFields<{
                accuracyRanges: FieldType<TypeFromFields<(...)>[]>;
                maxMeasuredValue: FieldType<number | bigint>;
                measured: FieldType<boolean>;
                measurementType: FieldType<MeasurementType>;
                minMeasuredValue: FieldType<number | bigint>;
            }>[], any>;
            activeCurrent: OptionalAttribute<null | number | bigint, any>;
            activePower: Attribute<null | number | bigint, any>;
            apparentCurrent: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            apparentPower: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            frequency: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            harmonicCurrents: Attribute<null | TypeFromFields<{
                measurement: FieldType<(...)>;
                order: FieldType<(...)>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    harmonics: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            harmonicPhases: Attribute<null | TypeFromFields<{
                measurement: FieldType<(...)>;
                order: FieldType<(...)>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerQuality: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            neutralCurrent: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    polyphasePower: boolean;
                }];
            };
            numberOfMeasurementTypes: FixedAttribute<number, any>;
            powerFactor: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            powerMode: Attribute<ElectricalPowerMeasurement.PowerMode, any>;
            ranges: OptionalAttribute<TypeFromFields<{
                endSystime: OptionalFieldType<number | bigint>;
                endTimestamp: OptionalFieldType<number>;
                max: FieldType<number | bigint>;
                maxSystime: OptionalFieldType<number | bigint>;
                maxTimestamp: OptionalFieldType<number>;
                measurementType: FieldType<MeasurementType>;
                min: FieldType<number | bigint>;
                minSystime: OptionalFieldType<number | bigint>;
                minTimestamp: OptionalFieldType<number>;
                startSystime: OptionalFieldType<number | bigint>;
                startTimestamp: OptionalFieldType<number>;
            }>[], any>;
            reactiveCurrent: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            reactivePower: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            rmsCurrent: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            rmsPower: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            rmsVoltage: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            voltage: OptionalAttribute<null | number | bigint, any>;
        };
        events: {
            measurementPeriodRanges: OptionalEvent<TypeFromFields<{
                ranges: FieldType<TypeFromFields<{
                    endSystime: ...;
                    endTimestamp: ...;
                    max: ...;
                    maxSystime: ...;
                    maxTimestamp: ...;
                    measurementType: ...;
                    min: ...;
                    minSystime: ...;
                    minTimestamp: ...;
                    startSystime: ...;
                    startTimestamp: ...;
                }>[]>;
            }>, any>;
        };
        features: {
            alternatingCurrent: BitFlag;
            directCurrent: BitFlag;
            harmonics: BitFlag;
            polyphasePower: BitFlag;
            powerQuality: BitFlag;
        };
        id: 144;
        name: "ElectricalPowerMeasurement";
        revision: 1;
    }>, FlagsT>;
    set<const ValuesT>(values: ValuesT): WithValues<Of<{
        attributes: {
            accuracy: FixedAttribute<TypeFromFields<{
                accuracyRanges: FieldType<TypeFromFields<(...)>[]>;
                maxMeasuredValue: FieldType<number | bigint>;
                measured: FieldType<boolean>;
                measurementType: FieldType<MeasurementType>;
                minMeasuredValue: FieldType<number | bigint>;
            }>[], any>;
            activeCurrent: OptionalAttribute<null | number | bigint, any>;
            activePower: Attribute<null | number | bigint, any>;
            apparentCurrent: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            apparentPower: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            frequency: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            harmonicCurrents: Attribute<null | TypeFromFields<{
                measurement: FieldType<(...)>;
                order: FieldType<(...)>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    harmonics: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            harmonicPhases: Attribute<null | TypeFromFields<{
                measurement: FieldType<(...)>;
                order: FieldType<(...)>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerQuality: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            neutralCurrent: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    polyphasePower: boolean;
                }];
            };
            numberOfMeasurementTypes: FixedAttribute<number, any>;
            powerFactor: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            powerMode: Attribute<ElectricalPowerMeasurement.PowerMode, any>;
            ranges: OptionalAttribute<TypeFromFields<{
                endSystime: OptionalFieldType<number | bigint>;
                endTimestamp: OptionalFieldType<number>;
                max: FieldType<number | bigint>;
                maxSystime: OptionalFieldType<number | bigint>;
                maxTimestamp: OptionalFieldType<number>;
                measurementType: FieldType<MeasurementType>;
                min: FieldType<number | bigint>;
                minSystime: OptionalFieldType<number | bigint>;
                minTimestamp: OptionalFieldType<number>;
                startSystime: OptionalFieldType<number | bigint>;
                startTimestamp: OptionalFieldType<number>;
            }>[], any>;
            reactiveCurrent: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            reactivePower: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            rmsCurrent: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            rmsPower: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            rmsVoltage: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            voltage: OptionalAttribute<null | number | bigint, any>;
        };
        events: {
            measurementPeriodRanges: OptionalEvent<TypeFromFields<{
                ranges: FieldType<TypeFromFields<{
                    endSystime: ...;
                    endTimestamp: ...;
                    max: ...;
                    maxSystime: ...;
                    maxTimestamp: ...;
                    measurementType: ...;
                    min: ...;
                    minSystime: ...;
                    minTimestamp: ...;
                    startSystime: ...;
                    startTimestamp: ...;
                }>[]>;
            }>, any>;
        };
        features: {
            alternatingCurrent: BitFlag;
            directCurrent: BitFlag;
            harmonics: BitFlag;
            polyphasePower: BitFlag;
            powerQuality: BitFlag;
        };
        id: 144;
        name: "ElectricalPowerMeasurement";
        revision: 1;
    }>, ValuesT>;
    with<const SelectionT>(...selection: SelectionT): Of<Of<{
        attributes: {
            accuracy: FixedAttribute<TypeFromFields<{
                accuracyRanges: FieldType<TypeFromFields<(...)>[]>;
                maxMeasuredValue: FieldType<number | bigint>;
                measured: FieldType<boolean>;
                measurementType: FieldType<MeasurementType>;
                minMeasuredValue: FieldType<number | bigint>;
            }>[], any>;
            activeCurrent: OptionalAttribute<null | number | bigint, any>;
            activePower: Attribute<null | number | bigint, any>;
            apparentCurrent: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            apparentPower: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            frequency: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            harmonicCurrents: Attribute<null | TypeFromFields<{
                measurement: FieldType<(...)>;
                order: FieldType<(...)>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    harmonics: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            harmonicPhases: Attribute<null | TypeFromFields<{
                measurement: FieldType<(...)>;
                order: FieldType<(...)>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerQuality: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            neutralCurrent: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    polyphasePower: boolean;
                }];
            };
            numberOfMeasurementTypes: FixedAttribute<number, any>;
            powerFactor: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            powerMode: Attribute<ElectricalPowerMeasurement.PowerMode, any>;
            ranges: OptionalAttribute<TypeFromFields<{
                endSystime: OptionalFieldType<number | bigint>;
                endTimestamp: OptionalFieldType<number>;
                max: FieldType<number | bigint>;
                maxSystime: OptionalFieldType<number | bigint>;
                maxTimestamp: OptionalFieldType<number>;
                measurementType: FieldType<MeasurementType>;
                min: FieldType<number | bigint>;
                minSystime: OptionalFieldType<number | bigint>;
                minTimestamp: OptionalFieldType<number>;
                startSystime: OptionalFieldType<number | bigint>;
                startTimestamp: OptionalFieldType<number>;
            }>[], any>;
            reactiveCurrent: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            reactivePower: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            rmsCurrent: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            rmsPower: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            rmsVoltage: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            voltage: OptionalAttribute<null | number | bigint, any>;
        };
        events: {
            measurementPeriodRanges: OptionalEvent<TypeFromFields<{
                ranges: FieldType<TypeFromFields<{
                    endSystime: ...;
                    endTimestamp: ...;
                    max: ...;
                    maxSystime: ...;
                    maxTimestamp: ...;
                    measurementType: ...;
                    min: ...;
                    minSystime: ...;
                    minTimestamp: ...;
                    startSystime: ...;
                    startTimestamp: ...;
                }>[]>;
            }>, any>;
        };
        features: {
            alternatingCurrent: BitFlag;
            directCurrent: BitFlag;
            harmonics: BitFlag;
            polyphasePower: BitFlag;
            powerQuality: BitFlag;
        };
        id: 144;
        name: "ElectricalPowerMeasurement";
        revision: 1;
    }>, SelectionT>;
}

Hierarchy (view full)

Properties

attributes base commands events extensions features id name revision supportedFeatures unknown

Methods

alter enable set with

Properties

attributes

attributes: Merge<{
    accuracy: FixedAttribute<TypeFromFields<{
        accuracyRanges: FieldType<TypeFromFields<{
            fixedMax: OptionalFieldType<(...)>;
            fixedMin: OptionalFieldType<(...)>;
            fixedTypical: OptionalFieldType<(...)>;
            percentMax: OptionalFieldType<(...)>;
            percentMin: OptionalFieldType<(...)>;
            percentTypical: OptionalFieldType<(...)>;
            rangeMax: FieldType<(...)>;
            rangeMin: FieldType<(...)>;
        }>[]>;
        maxMeasuredValue: FieldType<number | bigint>;
        measured: FieldType<boolean>;
        measurementType: FieldType<MeasurementType>;
        minMeasuredValue: FieldType<number | bigint>;
    }>[], any>;
    activeCurrent: OptionalAttribute<null | number | bigint, any>;
    activePower: Attribute<null | number | bigint, any>;
    apparentCurrent: OptionalAttribute<null | number | bigint, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            alternatingCurrent: boolean;
        }];
    };
    apparentPower: OptionalAttribute<null | number | bigint, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            alternatingCurrent: boolean;
        }];
    };
    frequency: OptionalAttribute<null | number | bigint, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            alternatingCurrent: boolean;
        }];
    };
    harmonicCurrents: Attribute<null | TypeFromFields<{
        measurement: FieldType<null | number | bigint>;
        order: FieldType<number>;
    }>[], any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            harmonics: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    harmonicPhases: Attribute<null | TypeFromFields<{
        measurement: FieldType<null | number | bigint>;
        order: FieldType<number>;
    }>[], any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            powerQuality: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    neutralCurrent: OptionalAttribute<null | number | bigint, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            polyphasePower: boolean;
        }];
    };
    numberOfMeasurementTypes: FixedAttribute<number, any>;
    powerFactor: OptionalAttribute<null | number | bigint, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            alternatingCurrent: boolean;
        }];
    };
    powerMode: Attribute<ElectricalPowerMeasurement.PowerMode, any>;
    ranges: OptionalAttribute<TypeFromFields<{
        endSystime: OptionalFieldType<number | bigint>;
        endTimestamp: OptionalFieldType<number>;
        max: FieldType<number | bigint>;
        maxSystime: OptionalFieldType<number | bigint>;
        maxTimestamp: OptionalFieldType<number>;
        measurementType: FieldType<MeasurementType>;
        min: FieldType<number | bigint>;
        minSystime: OptionalFieldType<number | bigint>;
        minTimestamp: OptionalFieldType<number>;
        startSystime: OptionalFieldType<number | bigint>;
        startTimestamp: OptionalFieldType<number>;
    }>[], any>;
    reactiveCurrent: OptionalAttribute<null | number | bigint, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            alternatingCurrent: boolean;
        }];
    };
    reactivePower: OptionalAttribute<null | number | bigint, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            alternatingCurrent: boolean;
        }];
    };
    rmsCurrent: OptionalAttribute<null | number | bigint, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            alternatingCurrent: boolean;
        }];
    };
    rmsPower: OptionalAttribute<null | number | bigint, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            alternatingCurrent: boolean;
        }];
    };
    rmsVoltage: OptionalAttribute<null | number | bigint, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            alternatingCurrent: boolean;
        }];
    };
    voltage: OptionalAttribute<null | number | bigint, any>;
}, GlobalAttributes<{
    alternatingCurrent: BitFlag;
    directCurrent: BitFlag;
    harmonics: BitFlag;
    polyphasePower: BitFlag;
    powerQuality: BitFlag;
}>>

Type declaration

  • Readonlyaccuracy: FixedAttribute<TypeFromFields<{
        accuracyRanges: FieldType<TypeFromFields<{
            fixedMax: OptionalFieldType<(...)>;
            fixedMin: OptionalFieldType<(...)>;
            fixedTypical: OptionalFieldType<(...)>;
            percentMax: OptionalFieldType<(...)>;
            percentMin: OptionalFieldType<(...)>;
            percentTypical: OptionalFieldType<(...)>;
            rangeMax: FieldType<(...)>;
            rangeMin: FieldType<(...)>;
        }>[]>;
        maxMeasuredValue: FieldType<number | bigint>;
        measured: FieldType<boolean>;
        measurementType: FieldType<MeasurementType>;
        minMeasuredValue: FieldType<number | bigint>;
    }>[], any>

    This shall indicate a list of accuracy specifications for the measurement types supported by the server. There shall be an entry for ActivePower, as well as any other measurement types implemented by this server.

    See

    MatterSpecification.v13.Cluster § 2.13.6.3

  • ReadonlyactiveCurrent: OptionalAttribute<null | number | bigint, any>

    This shall indicate the most recent ActiveCurrent reading in milliamps (mA).

    A positive value represents current flowing into the server, while a negative value represents current flowing out of the server.

    The reporting interval of this attribute shall be manufacturer dependent. The server may choose to omit publication of deltas considered not meaningful.

    The server shall NOT mark this attribute ready for report if the last time this was done was more recently than 1 second ago.

    The server may delay marking this attribute ready for report for longer periods if needed, however the server shall NOT delay marking this attribute as ready for report for longer than 60 seconds.

    If the current cannot be measured, a value of null shall be returned.

    See

    MatterSpecification.v13.Cluster § 2.13.6.6

  • ReadonlyactivePower: Attribute<null | number | bigint, any>

    This shall indicate the most recent ActivePower reading in milliwatts (mW). If the power cannot be measured, a value of null shall be returned.

    A positive value represents power imported, while a negative value represents power exported.

    The reporting interval of this attribute shall be manufacturer dependent. The server may choose to omit publication of deltas considered not meaningful.

    The server shall NOT mark this attribute ready for report if the last time this was done was more recently than 1 second ago.

    The server may delay marking this attribute ready for report for longer periods if needed, however the server shall NOT delay marking this attribute as ready for report for longer than 60 seconds.

    If the Polyphase Power feature is set, this value represents the combined active power imported or exported.

    See

    MatterSpecification.v13.Cluster § 2.13.6.9

  • ReadonlyapparentCurrent: OptionalAttribute<null | number | bigint, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            alternatingCurrent: boolean;
        }];
    }
  • ReadonlyapparentPower: OptionalAttribute<null | number | bigint, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            alternatingCurrent: boolean;
        }];
    }
  • Readonlyfrequency: OptionalAttribute<null | number | bigint, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            alternatingCurrent: boolean;
        }];
    }
  • ReadonlyharmonicCurrents: Attribute<null | TypeFromFields<{
        measurement: FieldType<null | number | bigint>;
        order: FieldType<number>;
    }>[], any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            harmonics: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlyharmonicPhases: Attribute<null | TypeFromFields<{
        measurement: FieldType<null | number | bigint>;
        order: FieldType<number>;
    }>[], any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            powerQuality: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlyneutralCurrent: OptionalAttribute<null | number | bigint, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            polyphasePower: boolean;
        }];
    }
  • ReadonlynumberOfMeasurementTypes: FixedAttribute<number, any>

    This shall indicate the maximum number of measurement types the server is capable of reporting.

    See

    MatterSpecification.v13.Cluster § 2.13.6.2

  • ReadonlypowerFactor: OptionalAttribute<null | number | bigint, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            alternatingCurrent: boolean;
        }];
    }
  • ReadonlypowerMode: Attribute<ElectricalPowerMeasurement.PowerMode, any>

    This shall indicate the current mode of the server. For some servers, such as an EV, this may change depending on the mode of charging or discharging.

    See

    MatterSpecification.v13.Cluster § 2.13.6.1

  • Readonlyranges: OptionalAttribute<TypeFromFields<{
        endSystime: OptionalFieldType<number | bigint>;
        endTimestamp: OptionalFieldType<number>;
        max: FieldType<number | bigint>;
        maxSystime: OptionalFieldType<number | bigint>;
        maxTimestamp: OptionalFieldType<number>;
        measurementType: FieldType<MeasurementType>;
        min: FieldType<number | bigint>;
        minSystime: OptionalFieldType<number | bigint>;
        minTimestamp: OptionalFieldType<number>;
        startSystime: OptionalFieldType<number | bigint>;
        startTimestamp: OptionalFieldType<number>;
    }>[], any>

    This shall indicate a list of measured ranges for different measurement types. Each measurement type shall have at most one entry in this list, representing the range of measurements in the most recent measurement period.

    The reporting interval of this attribute shall be manufacturer dependent. The server may choose to omit publication of deltas considered not meaningful.

    The server shall NOT mark this attribute ready for report if the last time this was done was more recently than 1 second ago.

    The server may delay marking this attribute ready for report for longer periods if needed, however the server shall NOT delay marking this attribute as ready for report for longer than 60 seconds.

    See

    MatterSpecification.v13.Cluster § 2.13.6.4

  • ReadonlyreactiveCurrent: OptionalAttribute<null | number | bigint, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            alternatingCurrent: boolean;
        }];
    }
  • ReadonlyreactivePower: OptionalAttribute<null | number | bigint, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            alternatingCurrent: boolean;
        }];
    }
  • ReadonlyrmsCurrent: OptionalAttribute<null | number | bigint, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            alternatingCurrent: boolean;
        }];
    }
  • ReadonlyrmsPower: OptionalAttribute<null | number | bigint, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            alternatingCurrent: boolean;
        }];
    }
  • ReadonlyrmsVoltage: OptionalAttribute<null | number | bigint, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            alternatingCurrent: boolean;
        }];
    }
  • Readonlyvoltage: OptionalAttribute<null | number | bigint, any>

    This shall indicate the most recent Voltage reading in millivolts (mV).

    The reporting interval of this attribute shall be manufacturer dependent. The server may choose to omit publication of deltas considered not meaningful.

    The server shall NOT mark this attribute ready for report if the last time this was done was more recently than 1 second ago.

    The server may delay marking this attribute ready for report for longer periods if needed, however the server shall NOT delay marking this attribute as ready for report for longer than 60 seconds.

    If the voltage cannot be measured, a value of null shall be returned.

    See

    MatterSpecification.v13.Cluster § 2.13.6.5

base

base: undefined

commands

commands: {}

events

events: {
    measurementPeriodRanges: OptionalEvent<TypeFromFields<{
        ranges: FieldType<TypeFromFields<{
            endSystime: OptionalFieldType<number | bigint>;
            endTimestamp: OptionalFieldType<number>;
            max: FieldType<number | bigint>;
            maxSystime: OptionalFieldType<number | bigint>;
            maxTimestamp: OptionalFieldType<number>;
            measurementType: FieldType<MeasurementType>;
            min: FieldType<number | bigint>;
            minSystime: OptionalFieldType<number | bigint>;
            minTimestamp: OptionalFieldType<number>;
            startSystime: OptionalFieldType<number | bigint>;
            startTimestamp: OptionalFieldType<number>;
        }>[]>;
    }>, any>;
}

Type declaration

extensions

extensions: undefined

features

features: {
    alternatingCurrent: BitFlag;
    directCurrent: BitFlag;
    harmonics: BitFlag;
    polyphasePower: BitFlag;
    powerQuality: BitFlag;
}

Type declaration

  • ReadonlyalternatingCurrent: BitFlag

    AlternatingCurrent

    This feature indicates the cluster can measure an alternating current.

    See

    MatterSpecification.v13.Cluster § 2.13.4.2

  • ReadonlydirectCurrent: BitFlag

    DirectCurrent

    This feature indicates the cluster can measure a direct current.

    See

    MatterSpecification.v13.Cluster § 2.13.4.1

  • Readonlyharmonics: BitFlag

    Harmonics

    This feature indicates the cluster can measure the harmonics of an alternating current.

    See

    MatterSpecification.v13.Cluster § 2.13.4.4

  • ReadonlypolyphasePower: BitFlag

    PolyphasePower

    This feature indicates the cluster represents the collective measurements for a Polyphase power supply.

    See

    MatterSpecification.v13.Cluster § 2.13.4.3

  • ReadonlypowerQuality: BitFlag

    PowerQuality

    This feature indicates the cluster can measure the harmonic phases of an alternating current.

    See

    MatterSpecification.v13.Cluster § 2.13.4.5

id

id: Branded<144, "ClusterId">

name

name

revision

revision

supportedFeatures

supportedFeatures: {}

unknown

unknown

Methods

alter

  • alter<const AlterationsT>(alterations): WithAlterations<Of<{
        attributes: {
            accuracy: FixedAttribute<TypeFromFields<{
                accuracyRanges: FieldType<TypeFromFields<(...)>[]>;
                maxMeasuredValue: FieldType<number | bigint>;
                measured: FieldType<boolean>;
                measurementType: FieldType<MeasurementType>;
                minMeasuredValue: FieldType<number | bigint>;
            }>[], any>;
            activeCurrent: OptionalAttribute<null | number | bigint, any>;
            activePower: Attribute<null | number | bigint, any>;
            apparentCurrent: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            apparentPower: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            frequency: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            harmonicCurrents: Attribute<null | TypeFromFields<{
                measurement: FieldType<(...)>;
                order: FieldType<(...)>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    harmonics: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            harmonicPhases: Attribute<null | TypeFromFields<{
                measurement: FieldType<(...)>;
                order: FieldType<(...)>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerQuality: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            neutralCurrent: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    polyphasePower: boolean;
                }];
            };
            numberOfMeasurementTypes: FixedAttribute<number, any>;
            powerFactor: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            powerMode: Attribute<ElectricalPowerMeasurement.PowerMode, any>;
            ranges: OptionalAttribute<TypeFromFields<{
                endSystime: OptionalFieldType<number | bigint>;
                endTimestamp: OptionalFieldType<number>;
                max: FieldType<number | bigint>;
                maxSystime: OptionalFieldType<number | bigint>;
                maxTimestamp: OptionalFieldType<number>;
                measurementType: FieldType<MeasurementType>;
                min: FieldType<number | bigint>;
                minSystime: OptionalFieldType<number | bigint>;
                minTimestamp: OptionalFieldType<number>;
                startSystime: OptionalFieldType<number | bigint>;
                startTimestamp: OptionalFieldType<number>;
            }>[], any>;
            reactiveCurrent: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            reactivePower: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            rmsCurrent: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            rmsPower: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            rmsVoltage: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            voltage: OptionalAttribute<null | number | bigint, any>;
        };
        events: {
            measurementPeriodRanges: OptionalEvent<TypeFromFields<{
                ranges: FieldType<TypeFromFields<{
                    endSystime: ...;
                    endTimestamp: ...;
                    max: ...;
                    maxSystime: ...;
                    maxTimestamp: ...;
                    measurementType: ...;
                    min: ...;
                    minSystime: ...;
                    minTimestamp: ...;
                    startSystime: ...;
                    startTimestamp: ...;
                }>[]>;
            }>, any>;
        };
        features: {
            alternatingCurrent: BitFlag;
            directCurrent: BitFlag;
            harmonics: BitFlag;
            polyphasePower: BitFlag;
            powerQuality: BitFlag;
        };
        id: 144;
        name: "ElectricalPowerMeasurement";
        revision: 1;
    }>, AlterationsT>

  • Modify elements using ElementModifier.alter.

    Type Parameters

    • const AlterationsT extends Alterations<Of<{
          attributes: {
              accuracy: FixedAttribute<TypeFromFields<{
                  accuracyRanges: FieldType<TypeFromFields<(...)>[]>;
                  maxMeasuredValue: FieldType<number | bigint>;
                  measured: FieldType<boolean>;
                  measurementType: FieldType<MeasurementType>;
                  minMeasuredValue: FieldType<number | bigint>;
              }>[], any>;
              activeCurrent: OptionalAttribute<null | number | bigint, any>;
              activePower: Attribute<null | number | bigint, any>;
              apparentCurrent: OptionalAttribute<null | number | bigint, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      alternatingCurrent: boolean;
                  }];
              };
              apparentPower: OptionalAttribute<null | number | bigint, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      alternatingCurrent: boolean;
                  }];
              };
              frequency: OptionalAttribute<null | number | bigint, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      alternatingCurrent: boolean;
                  }];
              };
              harmonicCurrents: Attribute<null | TypeFromFields<{
                  measurement: FieldType<(...)>;
                  order: FieldType<(...)>;
              }>[], any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      harmonics: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              harmonicPhases: Attribute<null | TypeFromFields<{
                  measurement: FieldType<(...)>;
                  order: FieldType<(...)>;
              }>[], any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      powerQuality: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              neutralCurrent: OptionalAttribute<null | number | bigint, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      polyphasePower: boolean;
                  }];
              };
              numberOfMeasurementTypes: FixedAttribute<number, any>;
              powerFactor: OptionalAttribute<null | number | bigint, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      alternatingCurrent: boolean;
                  }];
              };
              powerMode: Attribute<ElectricalPowerMeasurement.PowerMode, any>;
              ranges: OptionalAttribute<TypeFromFields<{
                  endSystime: OptionalFieldType<number | bigint>;
                  endTimestamp: OptionalFieldType<number>;
                  max: FieldType<number | bigint>;
                  maxSystime: OptionalFieldType<number | bigint>;
                  maxTimestamp: OptionalFieldType<number>;
                  measurementType: FieldType<MeasurementType>;
                  min: FieldType<number | bigint>;
                  minSystime: OptionalFieldType<number | bigint>;
                  minTimestamp: OptionalFieldType<number>;
                  startSystime: OptionalFieldType<number | bigint>;
                  startTimestamp: OptionalFieldType<number>;
              }>[], any>;
              reactiveCurrent: OptionalAttribute<null | number | bigint, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      alternatingCurrent: boolean;
                  }];
              };
              reactivePower: OptionalAttribute<null | number | bigint, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      alternatingCurrent: boolean;
                  }];
              };
              rmsCurrent: OptionalAttribute<null | number | bigint, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      alternatingCurrent: boolean;
                  }];
              };
              rmsPower: OptionalAttribute<null | number | bigint, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      alternatingCurrent: boolean;
                  }];
              };
              rmsVoltage: OptionalAttribute<null | number | bigint, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      alternatingCurrent: boolean;
                  }];
              };
              voltage: OptionalAttribute<null | number | bigint, any>;
          };
          events: {
              measurementPeriodRanges: OptionalEvent<TypeFromFields<{
                  ranges: FieldType<TypeFromFields<{
                      endSystime: ...;
                      endTimestamp: ...;
                      max: ...;
                      maxSystime: ...;
                      maxTimestamp: ...;
                      measurementType: ...;
                      min: ...;
                      minSystime: ...;
                      minTimestamp: ...;
                      startSystime: ...;
                      startTimestamp: ...;
                  }>[]>;
              }>, any>;
          };
          features: {
              alternatingCurrent: BitFlag;
              directCurrent: BitFlag;
              harmonics: BitFlag;
              polyphasePower: BitFlag;
              powerQuality: BitFlag;
          };
          id: 144;
          name: "ElectricalPowerMeasurement";
          revision: 1;
      }>>

    Parameters

    Returns WithAlterations<Of<{
        attributes: {
            accuracy: FixedAttribute<TypeFromFields<{
                accuracyRanges: FieldType<TypeFromFields<(...)>[]>;
                maxMeasuredValue: FieldType<number | bigint>;
                measured: FieldType<boolean>;
                measurementType: FieldType<MeasurementType>;
                minMeasuredValue: FieldType<number | bigint>;
            }>[], any>;
            activeCurrent: OptionalAttribute<null | number | bigint, any>;
            activePower: Attribute<null | number | bigint, any>;
            apparentCurrent: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            apparentPower: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            frequency: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            harmonicCurrents: Attribute<null | TypeFromFields<{
                measurement: FieldType<(...)>;
                order: FieldType<(...)>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    harmonics: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            harmonicPhases: Attribute<null | TypeFromFields<{
                measurement: FieldType<(...)>;
                order: FieldType<(...)>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerQuality: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            neutralCurrent: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    polyphasePower: boolean;
                }];
            };
            numberOfMeasurementTypes: FixedAttribute<number, any>;
            powerFactor: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            powerMode: Attribute<ElectricalPowerMeasurement.PowerMode, any>;
            ranges: OptionalAttribute<TypeFromFields<{
                endSystime: OptionalFieldType<number | bigint>;
                endTimestamp: OptionalFieldType<number>;
                max: FieldType<number | bigint>;
                maxSystime: OptionalFieldType<number | bigint>;
                maxTimestamp: OptionalFieldType<number>;
                measurementType: FieldType<MeasurementType>;
                min: FieldType<number | bigint>;
                minSystime: OptionalFieldType<number | bigint>;
                minTimestamp: OptionalFieldType<number>;
                startSystime: OptionalFieldType<number | bigint>;
                startTimestamp: OptionalFieldType<number>;
            }>[], any>;
            reactiveCurrent: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            reactivePower: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            rmsCurrent: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            rmsPower: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            rmsVoltage: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            voltage: OptionalAttribute<null | number | bigint, any>;
        };
        events: {
            measurementPeriodRanges: OptionalEvent<TypeFromFields<{
                ranges: FieldType<TypeFromFields<{
                    endSystime: ...;
                    endTimestamp: ...;
                    max: ...;
                    maxSystime: ...;
                    maxTimestamp: ...;
                    measurementType: ...;
                    min: ...;
                    minSystime: ...;
                    minTimestamp: ...;
                    startSystime: ...;
                    startTimestamp: ...;
                }>[]>;
            }>, any>;
        };
        features: {
            alternatingCurrent: BitFlag;
            directCurrent: BitFlag;
            harmonics: BitFlag;
            polyphasePower: BitFlag;
            powerQuality: BitFlag;
        };
        id: 144;
        name: "ElectricalPowerMeasurement";
        revision: 1;
    }>, AlterationsT>

enable

  • enable<const FlagsT>(flags): WithFlags<Of<{
        attributes: {
            accuracy: FixedAttribute<TypeFromFields<{
                accuracyRanges: FieldType<TypeFromFields<(...)>[]>;
                maxMeasuredValue: FieldType<number | bigint>;
                measured: FieldType<boolean>;
                measurementType: FieldType<MeasurementType>;
                minMeasuredValue: FieldType<number | bigint>;
            }>[], any>;
            activeCurrent: OptionalAttribute<null | number | bigint, any>;
            activePower: Attribute<null | number | bigint, any>;
            apparentCurrent: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            apparentPower: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            frequency: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            harmonicCurrents: Attribute<null | TypeFromFields<{
                measurement: FieldType<(...)>;
                order: FieldType<(...)>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    harmonics: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            harmonicPhases: Attribute<null | TypeFromFields<{
                measurement: FieldType<(...)>;
                order: FieldType<(...)>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerQuality: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            neutralCurrent: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    polyphasePower: boolean;
                }];
            };
            numberOfMeasurementTypes: FixedAttribute<number, any>;
            powerFactor: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            powerMode: Attribute<ElectricalPowerMeasurement.PowerMode, any>;
            ranges: OptionalAttribute<TypeFromFields<{
                endSystime: OptionalFieldType<number | bigint>;
                endTimestamp: OptionalFieldType<number>;
                max: FieldType<number | bigint>;
                maxSystime: OptionalFieldType<number | bigint>;
                maxTimestamp: OptionalFieldType<number>;
                measurementType: FieldType<MeasurementType>;
                min: FieldType<number | bigint>;
                minSystime: OptionalFieldType<number | bigint>;
                minTimestamp: OptionalFieldType<number>;
                startSystime: OptionalFieldType<number | bigint>;
                startTimestamp: OptionalFieldType<number>;
            }>[], any>;
            reactiveCurrent: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            reactivePower: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            rmsCurrent: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            rmsPower: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            rmsVoltage: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            voltage: OptionalAttribute<null | number | bigint, any>;
        };
        events: {
            measurementPeriodRanges: OptionalEvent<TypeFromFields<{
                ranges: FieldType<TypeFromFields<{
                    endSystime: ...;
                    endTimestamp: ...;
                    max: ...;
                    maxSystime: ...;
                    maxTimestamp: ...;
                    measurementType: ...;
                    min: ...;
                    minSystime: ...;
                    minTimestamp: ...;
                    startSystime: ...;
                    startTimestamp: ...;
                }>[]>;
            }>, any>;
        };
        features: {
            alternatingCurrent: BitFlag;
            directCurrent: BitFlag;
            harmonics: BitFlag;
            polyphasePower: BitFlag;
            powerQuality: BitFlag;
        };
        id: 144;
        name: "ElectricalPowerMeasurement";
        revision: 1;
    }>, FlagsT>

  • Modify elements using ElementModifier.enable.

    Type Parameters

    • const FlagsT extends ElementFlags<Of<{
          attributes: {
              accuracy: FixedAttribute<TypeFromFields<{
                  accuracyRanges: FieldType<TypeFromFields<(...)>[]>;
                  maxMeasuredValue: FieldType<number | bigint>;
                  measured: FieldType<boolean>;
                  measurementType: FieldType<MeasurementType>;
                  minMeasuredValue: FieldType<number | bigint>;
              }>[], any>;
              activeCurrent: OptionalAttribute<null | number | bigint, any>;
              activePower: Attribute<null | number | bigint, any>;
              apparentCurrent: OptionalAttribute<null | number | bigint, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      alternatingCurrent: boolean;
                  }];
              };
              apparentPower: OptionalAttribute<null | number | bigint, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      alternatingCurrent: boolean;
                  }];
              };
              frequency: OptionalAttribute<null | number | bigint, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      alternatingCurrent: boolean;
                  }];
              };
              harmonicCurrents: Attribute<null | TypeFromFields<{
                  measurement: FieldType<(...)>;
                  order: FieldType<(...)>;
              }>[], any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      harmonics: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              harmonicPhases: Attribute<null | TypeFromFields<{
                  measurement: FieldType<(...)>;
                  order: FieldType<(...)>;
              }>[], any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      powerQuality: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              neutralCurrent: OptionalAttribute<null | number | bigint, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      polyphasePower: boolean;
                  }];
              };
              numberOfMeasurementTypes: FixedAttribute<number, any>;
              powerFactor: OptionalAttribute<null | number | bigint, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      alternatingCurrent: boolean;
                  }];
              };
              powerMode: Attribute<ElectricalPowerMeasurement.PowerMode, any>;
              ranges: OptionalAttribute<TypeFromFields<{
                  endSystime: OptionalFieldType<number | bigint>;
                  endTimestamp: OptionalFieldType<number>;
                  max: FieldType<number | bigint>;
                  maxSystime: OptionalFieldType<number | bigint>;
                  maxTimestamp: OptionalFieldType<number>;
                  measurementType: FieldType<MeasurementType>;
                  min: FieldType<number | bigint>;
                  minSystime: OptionalFieldType<number | bigint>;
                  minTimestamp: OptionalFieldType<number>;
                  startSystime: OptionalFieldType<number | bigint>;
                  startTimestamp: OptionalFieldType<number>;
              }>[], any>;
              reactiveCurrent: OptionalAttribute<null | number | bigint, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      alternatingCurrent: boolean;
                  }];
              };
              reactivePower: OptionalAttribute<null | number | bigint, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      alternatingCurrent: boolean;
                  }];
              };
              rmsCurrent: OptionalAttribute<null | number | bigint, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      alternatingCurrent: boolean;
                  }];
              };
              rmsPower: OptionalAttribute<null | number | bigint, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      alternatingCurrent: boolean;
                  }];
              };
              rmsVoltage: OptionalAttribute<null | number | bigint, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      alternatingCurrent: boolean;
                  }];
              };
              voltage: OptionalAttribute<null | number | bigint, any>;
          };
          events: {
              measurementPeriodRanges: OptionalEvent<TypeFromFields<{
                  ranges: FieldType<TypeFromFields<{
                      endSystime: ...;
                      endTimestamp: ...;
                      max: ...;
                      maxSystime: ...;
                      maxTimestamp: ...;
                      measurementType: ...;
                      min: ...;
                      minSystime: ...;
                      minTimestamp: ...;
                      startSystime: ...;
                      startTimestamp: ...;
                  }>[]>;
              }>, any>;
          };
          features: {
              alternatingCurrent: BitFlag;
              directCurrent: BitFlag;
              harmonics: BitFlag;
              polyphasePower: BitFlag;
              powerQuality: BitFlag;
          };
          id: 144;
          name: "ElectricalPowerMeasurement";
          revision: 1;
      }>>

    Parameters

    Returns WithFlags<Of<{
        attributes: {
            accuracy: FixedAttribute<TypeFromFields<{
                accuracyRanges: FieldType<TypeFromFields<(...)>[]>;
                maxMeasuredValue: FieldType<number | bigint>;
                measured: FieldType<boolean>;
                measurementType: FieldType<MeasurementType>;
                minMeasuredValue: FieldType<number | bigint>;
            }>[], any>;
            activeCurrent: OptionalAttribute<null | number | bigint, any>;
            activePower: Attribute<null | number | bigint, any>;
            apparentCurrent: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            apparentPower: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            frequency: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            harmonicCurrents: Attribute<null | TypeFromFields<{
                measurement: FieldType<(...)>;
                order: FieldType<(...)>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    harmonics: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            harmonicPhases: Attribute<null | TypeFromFields<{
                measurement: FieldType<(...)>;
                order: FieldType<(...)>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerQuality: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            neutralCurrent: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    polyphasePower: boolean;
                }];
            };
            numberOfMeasurementTypes: FixedAttribute<number, any>;
            powerFactor: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            powerMode: Attribute<ElectricalPowerMeasurement.PowerMode, any>;
            ranges: OptionalAttribute<TypeFromFields<{
                endSystime: OptionalFieldType<number | bigint>;
                endTimestamp: OptionalFieldType<number>;
                max: FieldType<number | bigint>;
                maxSystime: OptionalFieldType<number | bigint>;
                maxTimestamp: OptionalFieldType<number>;
                measurementType: FieldType<MeasurementType>;
                min: FieldType<number | bigint>;
                minSystime: OptionalFieldType<number | bigint>;
                minTimestamp: OptionalFieldType<number>;
                startSystime: OptionalFieldType<number | bigint>;
                startTimestamp: OptionalFieldType<number>;
            }>[], any>;
            reactiveCurrent: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            reactivePower: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            rmsCurrent: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            rmsPower: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            rmsVoltage: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            voltage: OptionalAttribute<null | number | bigint, any>;
        };
        events: {
            measurementPeriodRanges: OptionalEvent<TypeFromFields<{
                ranges: FieldType<TypeFromFields<{
                    endSystime: ...;
                    endTimestamp: ...;
                    max: ...;
                    maxSystime: ...;
                    maxTimestamp: ...;
                    measurementType: ...;
                    min: ...;
                    minSystime: ...;
                    minTimestamp: ...;
                    startSystime: ...;
                    startTimestamp: ...;
                }>[]>;
            }>, any>;
        };
        features: {
            alternatingCurrent: BitFlag;
            directCurrent: BitFlag;
            harmonics: BitFlag;
            polyphasePower: BitFlag;
            powerQuality: BitFlag;
        };
        id: 144;
        name: "ElectricalPowerMeasurement";
        revision: 1;
    }>, FlagsT>

set

  • set<const ValuesT>(values): WithValues<Of<{
        attributes: {
            accuracy: FixedAttribute<TypeFromFields<{
                accuracyRanges: FieldType<TypeFromFields<(...)>[]>;
                maxMeasuredValue: FieldType<number | bigint>;
                measured: FieldType<boolean>;
                measurementType: FieldType<MeasurementType>;
                minMeasuredValue: FieldType<number | bigint>;
            }>[], any>;
            activeCurrent: OptionalAttribute<null | number | bigint, any>;
            activePower: Attribute<null | number | bigint, any>;
            apparentCurrent: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            apparentPower: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            frequency: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            harmonicCurrents: Attribute<null | TypeFromFields<{
                measurement: FieldType<(...)>;
                order: FieldType<(...)>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    harmonics: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            harmonicPhases: Attribute<null | TypeFromFields<{
                measurement: FieldType<(...)>;
                order: FieldType<(...)>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerQuality: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            neutralCurrent: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    polyphasePower: boolean;
                }];
            };
            numberOfMeasurementTypes: FixedAttribute<number, any>;
            powerFactor: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            powerMode: Attribute<ElectricalPowerMeasurement.PowerMode, any>;
            ranges: OptionalAttribute<TypeFromFields<{
                endSystime: OptionalFieldType<number | bigint>;
                endTimestamp: OptionalFieldType<number>;
                max: FieldType<number | bigint>;
                maxSystime: OptionalFieldType<number | bigint>;
                maxTimestamp: OptionalFieldType<number>;
                measurementType: FieldType<MeasurementType>;
                min: FieldType<number | bigint>;
                minSystime: OptionalFieldType<number | bigint>;
                minTimestamp: OptionalFieldType<number>;
                startSystime: OptionalFieldType<number | bigint>;
                startTimestamp: OptionalFieldType<number>;
            }>[], any>;
            reactiveCurrent: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            reactivePower: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            rmsCurrent: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            rmsPower: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            rmsVoltage: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            voltage: OptionalAttribute<null | number | bigint, any>;
        };
        events: {
            measurementPeriodRanges: OptionalEvent<TypeFromFields<{
                ranges: FieldType<TypeFromFields<{
                    endSystime: ...;
                    endTimestamp: ...;
                    max: ...;
                    maxSystime: ...;
                    maxTimestamp: ...;
                    measurementType: ...;
                    min: ...;
                    minSystime: ...;
                    minTimestamp: ...;
                    startSystime: ...;
                    startTimestamp: ...;
                }>[]>;
            }>, any>;
        };
        features: {
            alternatingCurrent: BitFlag;
            directCurrent: BitFlag;
            harmonics: BitFlag;
            polyphasePower: BitFlag;
            powerQuality: BitFlag;
        };
        id: 144;
        name: "ElectricalPowerMeasurement";
        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;
          }[];
          activeCurrent?: null | number | bigint;
          activePower: null | number | bigint;
          apparentCurrent?: null | number | bigint;
          apparentPower?: null | number | bigint;
          frequency?: null | number | bigint;
          harmonicCurrents?: null | {
              measurement: null | number | bigint;
              order: number;
          }[];
          harmonicPhases?: null | {
              measurement: null | number | bigint;
              order: number;
          }[];
          neutralCurrent?: null | number | bigint;
          numberOfMeasurementTypes: number;
          powerFactor?: null | number | bigint;
          powerMode: number;
          ranges?: {
              endSystime?: number | bigint;
              endTimestamp?: number;
              max: number | bigint;
              maxSystime?: number | bigint;
              maxTimestamp?: number;
              measurementType: number;
              min: number | bigint;
              minSystime?: number | bigint;
              minTimestamp?: number;
              startSystime?: number | bigint;
              startTimestamp?: number;
          }[];
          reactiveCurrent?: null | number | bigint;
          reactivePower?: null | number | bigint;
          rmsCurrent?: null | number | bigint;
          rmsPower?: null | number | bigint;
          rmsVoltage?: null | number | bigint;
          voltage?: null | number | bigint;
      }

    Parameters

    Returns WithValues<Of<{
        attributes: {
            accuracy: FixedAttribute<TypeFromFields<{
                accuracyRanges: FieldType<TypeFromFields<(...)>[]>;
                maxMeasuredValue: FieldType<number | bigint>;
                measured: FieldType<boolean>;
                measurementType: FieldType<MeasurementType>;
                minMeasuredValue: FieldType<number | bigint>;
            }>[], any>;
            activeCurrent: OptionalAttribute<null | number | bigint, any>;
            activePower: Attribute<null | number | bigint, any>;
            apparentCurrent: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            apparentPower: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            frequency: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            harmonicCurrents: Attribute<null | TypeFromFields<{
                measurement: FieldType<(...)>;
                order: FieldType<(...)>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    harmonics: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            harmonicPhases: Attribute<null | TypeFromFields<{
                measurement: FieldType<(...)>;
                order: FieldType<(...)>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerQuality: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            neutralCurrent: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    polyphasePower: boolean;
                }];
            };
            numberOfMeasurementTypes: FixedAttribute<number, any>;
            powerFactor: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            powerMode: Attribute<ElectricalPowerMeasurement.PowerMode, any>;
            ranges: OptionalAttribute<TypeFromFields<{
                endSystime: OptionalFieldType<number | bigint>;
                endTimestamp: OptionalFieldType<number>;
                max: FieldType<number | bigint>;
                maxSystime: OptionalFieldType<number | bigint>;
                maxTimestamp: OptionalFieldType<number>;
                measurementType: FieldType<MeasurementType>;
                min: FieldType<number | bigint>;
                minSystime: OptionalFieldType<number | bigint>;
                minTimestamp: OptionalFieldType<number>;
                startSystime: OptionalFieldType<number | bigint>;
                startTimestamp: OptionalFieldType<number>;
            }>[], any>;
            reactiveCurrent: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            reactivePower: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            rmsCurrent: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            rmsPower: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            rmsVoltage: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            voltage: OptionalAttribute<null | number | bigint, any>;
        };
        events: {
            measurementPeriodRanges: OptionalEvent<TypeFromFields<{
                ranges: FieldType<TypeFromFields<{
                    endSystime: ...;
                    endTimestamp: ...;
                    max: ...;
                    maxSystime: ...;
                    maxTimestamp: ...;
                    measurementType: ...;
                    min: ...;
                    minSystime: ...;
                    minTimestamp: ...;
                    startSystime: ...;
                    startTimestamp: ...;
                }>[]>;
            }>, any>;
        };
        features: {
            alternatingCurrent: BitFlag;
            directCurrent: BitFlag;
            harmonics: BitFlag;
            polyphasePower: BitFlag;
            powerQuality: BitFlag;
        };
        id: 144;
        name: "ElectricalPowerMeasurement";
        revision: 1;
    }>, ValuesT>

with

  • with<const SelectionT>(...selection): Of<Of<{
        attributes: {
            accuracy: FixedAttribute<TypeFromFields<{
                accuracyRanges: FieldType<TypeFromFields<(...)>[]>;
                maxMeasuredValue: FieldType<number | bigint>;
                measured: FieldType<boolean>;
                measurementType: FieldType<MeasurementType>;
                minMeasuredValue: FieldType<number | bigint>;
            }>[], any>;
            activeCurrent: OptionalAttribute<null | number | bigint, any>;
            activePower: Attribute<null | number | bigint, any>;
            apparentCurrent: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            apparentPower: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            frequency: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            harmonicCurrents: Attribute<null | TypeFromFields<{
                measurement: FieldType<(...)>;
                order: FieldType<(...)>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    harmonics: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            harmonicPhases: Attribute<null | TypeFromFields<{
                measurement: FieldType<(...)>;
                order: FieldType<(...)>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerQuality: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            neutralCurrent: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    polyphasePower: boolean;
                }];
            };
            numberOfMeasurementTypes: FixedAttribute<number, any>;
            powerFactor: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            powerMode: Attribute<ElectricalPowerMeasurement.PowerMode, any>;
            ranges: OptionalAttribute<TypeFromFields<{
                endSystime: OptionalFieldType<number | bigint>;
                endTimestamp: OptionalFieldType<number>;
                max: FieldType<number | bigint>;
                maxSystime: OptionalFieldType<number | bigint>;
                maxTimestamp: OptionalFieldType<number>;
                measurementType: FieldType<MeasurementType>;
                min: FieldType<number | bigint>;
                minSystime: OptionalFieldType<number | bigint>;
                minTimestamp: OptionalFieldType<number>;
                startSystime: OptionalFieldType<number | bigint>;
                startTimestamp: OptionalFieldType<number>;
            }>[], any>;
            reactiveCurrent: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            reactivePower: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            rmsCurrent: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            rmsPower: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            rmsVoltage: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            voltage: OptionalAttribute<null | number | bigint, any>;
        };
        events: {
            measurementPeriodRanges: OptionalEvent<TypeFromFields<{
                ranges: FieldType<TypeFromFields<{
                    endSystime: ...;
                    endTimestamp: ...;
                    max: ...;
                    maxSystime: ...;
                    maxTimestamp: ...;
                    measurementType: ...;
                    min: ...;
                    minSystime: ...;
                    minTimestamp: ...;
                    startSystime: ...;
                    startTimestamp: ...;
                }>[]>;
            }>, any>;
        };
        features: {
            alternatingCurrent: BitFlag;
            directCurrent: BitFlag;
            harmonics: BitFlag;
            polyphasePower: BitFlag;
            powerQuality: BitFlag;
        };
        id: 144;
        name: "ElectricalPowerMeasurement";
        revision: 1;
    }>, SelectionT>

  • Select features using ClusterComposer.compose.

    Type Parameters

    • const SelectionT extends FeatureSelection<Of<{
          attributes: {
              accuracy: FixedAttribute<TypeFromFields<{
                  accuracyRanges: FieldType<TypeFromFields<(...)>[]>;
                  maxMeasuredValue: FieldType<number | bigint>;
                  measured: FieldType<boolean>;
                  measurementType: FieldType<MeasurementType>;
                  minMeasuredValue: FieldType<number | bigint>;
              }>[], any>;
              activeCurrent: OptionalAttribute<null | number | bigint, any>;
              activePower: Attribute<null | number | bigint, any>;
              apparentCurrent: OptionalAttribute<null | number | bigint, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      alternatingCurrent: boolean;
                  }];
              };
              apparentPower: OptionalAttribute<null | number | bigint, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      alternatingCurrent: boolean;
                  }];
              };
              frequency: OptionalAttribute<null | number | bigint, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      alternatingCurrent: boolean;
                  }];
              };
              harmonicCurrents: Attribute<null | TypeFromFields<{
                  measurement: FieldType<(...)>;
                  order: FieldType<(...)>;
              }>[], any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      harmonics: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              harmonicPhases: Attribute<null | TypeFromFields<{
                  measurement: FieldType<(...)>;
                  order: FieldType<(...)>;
              }>[], any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      powerQuality: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              neutralCurrent: OptionalAttribute<null | number | bigint, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      polyphasePower: boolean;
                  }];
              };
              numberOfMeasurementTypes: FixedAttribute<number, any>;
              powerFactor: OptionalAttribute<null | number | bigint, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      alternatingCurrent: boolean;
                  }];
              };
              powerMode: Attribute<ElectricalPowerMeasurement.PowerMode, any>;
              ranges: OptionalAttribute<TypeFromFields<{
                  endSystime: OptionalFieldType<number | bigint>;
                  endTimestamp: OptionalFieldType<number>;
                  max: FieldType<number | bigint>;
                  maxSystime: OptionalFieldType<number | bigint>;
                  maxTimestamp: OptionalFieldType<number>;
                  measurementType: FieldType<MeasurementType>;
                  min: FieldType<number | bigint>;
                  minSystime: OptionalFieldType<number | bigint>;
                  minTimestamp: OptionalFieldType<number>;
                  startSystime: OptionalFieldType<number | bigint>;
                  startTimestamp: OptionalFieldType<number>;
              }>[], any>;
              reactiveCurrent: OptionalAttribute<null | number | bigint, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      alternatingCurrent: boolean;
                  }];
              };
              reactivePower: OptionalAttribute<null | number | bigint, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      alternatingCurrent: boolean;
                  }];
              };
              rmsCurrent: OptionalAttribute<null | number | bigint, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      alternatingCurrent: boolean;
                  }];
              };
              rmsPower: OptionalAttribute<null | number | bigint, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      alternatingCurrent: boolean;
                  }];
              };
              rmsVoltage: OptionalAttribute<null | number | bigint, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      alternatingCurrent: boolean;
                  }];
              };
              voltage: OptionalAttribute<null | number | bigint, any>;
          };
          events: {
              measurementPeriodRanges: OptionalEvent<TypeFromFields<{
                  ranges: FieldType<TypeFromFields<{
                      endSystime: ...;
                      endTimestamp: ...;
                      max: ...;
                      maxSystime: ...;
                      maxTimestamp: ...;
                      measurementType: ...;
                      min: ...;
                      minSystime: ...;
                      minTimestamp: ...;
                      startSystime: ...;
                      startTimestamp: ...;
                  }>[]>;
              }>, any>;
          };
          features: {
              alternatingCurrent: BitFlag;
              directCurrent: BitFlag;
              harmonics: BitFlag;
              polyphasePower: BitFlag;
              powerQuality: BitFlag;
          };
          id: 144;
          name: "ElectricalPowerMeasurement";
          revision: 1;
      }>>

    Parameters

    Returns Of<Of<{
        attributes: {
            accuracy: FixedAttribute<TypeFromFields<{
                accuracyRanges: FieldType<TypeFromFields<(...)>[]>;
                maxMeasuredValue: FieldType<number | bigint>;
                measured: FieldType<boolean>;
                measurementType: FieldType<MeasurementType>;
                minMeasuredValue: FieldType<number | bigint>;
            }>[], any>;
            activeCurrent: OptionalAttribute<null | number | bigint, any>;
            activePower: Attribute<null | number | bigint, any>;
            apparentCurrent: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            apparentPower: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            frequency: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            harmonicCurrents: Attribute<null | TypeFromFields<{
                measurement: FieldType<(...)>;
                order: FieldType<(...)>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    harmonics: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            harmonicPhases: Attribute<null | TypeFromFields<{
                measurement: FieldType<(...)>;
                order: FieldType<(...)>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerQuality: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            neutralCurrent: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    polyphasePower: boolean;
                }];
            };
            numberOfMeasurementTypes: FixedAttribute<number, any>;
            powerFactor: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            powerMode: Attribute<ElectricalPowerMeasurement.PowerMode, any>;
            ranges: OptionalAttribute<TypeFromFields<{
                endSystime: OptionalFieldType<number | bigint>;
                endTimestamp: OptionalFieldType<number>;
                max: FieldType<number | bigint>;
                maxSystime: OptionalFieldType<number | bigint>;
                maxTimestamp: OptionalFieldType<number>;
                measurementType: FieldType<MeasurementType>;
                min: FieldType<number | bigint>;
                minSystime: OptionalFieldType<number | bigint>;
                minTimestamp: OptionalFieldType<number>;
                startSystime: OptionalFieldType<number | bigint>;
                startTimestamp: OptionalFieldType<number>;
            }>[], any>;
            reactiveCurrent: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            reactivePower: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            rmsCurrent: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            rmsPower: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            rmsVoltage: OptionalAttribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    alternatingCurrent: boolean;
                }];
            };
            voltage: OptionalAttribute<null | number | bigint, any>;
        };
        events: {
            measurementPeriodRanges: OptionalEvent<TypeFromFields<{
                ranges: FieldType<TypeFromFields<{
                    endSystime: ...;
                    endTimestamp: ...;
                    max: ...;
                    maxSystime: ...;
                    maxTimestamp: ...;
                    measurementType: ...;
                    min: ...;
                    minSystime: ...;
                    minTimestamp: ...;
                    startSystime: ...;
                    startTimestamp: ...;
                }>[]>;
            }>, any>;
        };
        features: {
            alternatingCurrent: BitFlag;
            directCurrent: BitFlag;
            harmonics: BitFlag;
            polyphasePower: BitFlag;
            powerQuality: BitFlag;
        };
        id: 144;
        name: "ElectricalPowerMeasurement";
        revision: 1;
    }>, SelectionT>

Settings

Member Visibility

On This Page

Properties
Methods