Class ElectricalPowerMeasurementServer

This is the default server implementation of ElectricalPowerMeasurementBehavior.

The Matter specification requires the ElectricalPowerMeasurement cluster to support features we do not enable by default. You should use ElectricalPowerMeasurementServer.with to specialize the class for the features your implementation supports.

Hierarchy (view full)

ElectricalPowerMeasurementBehavior
- ElectricalPowerMeasurementServer

Constructors

constructor

new ElectricalPowerMeasurementServer(agent, backing): ElectricalPowerMeasurementServer
Parameters
- agent: Agent
- backing: BehaviorBacking
Returns ElectricalPowerMeasurementServer
Inherited from ElectricalPowerMeasurementBehavior.constructor
- Defined in packages/node/src/behavior/cluster/ClusterBehavior.ts:198

Properties

[reference]

[reference]: Datasource<StateType>

agent

agent: Agent

cluster

cluster: never

The implemented cluster.

`Readonly`events

events: EventEmitter & Omit<Events, never> & {
    accuracy$Changing: ClusterEvents.AttributeObservable<FixedAttribute<TypeFromFields<{
        accuracyRanges: FieldType<TypeFromFields<{
            fixedMax: ...;
            fixedMin: ...;
            fixedTypical: ...;
            percentMax: ...;
            percentMin: ...;
            percentTypical: ...;
            rangeMax: ...;
            rangeMin: ...;
        }>[]>;
        maxMeasuredValue: FieldType<number | bigint>;
        measured: FieldType<boolean>;
        measurementType: FieldType<MeasurementType>;
        minMeasuredValue: FieldType<number | bigint>;
    }>[], any>>;
    activePower$Changing: ClusterEvents.AttributeObservable<Attribute<null | number | bigint, any>>;
    numberOfMeasurementTypes$Changing: ClusterEvents.AttributeObservable<FixedAttribute<number, any>>;
    powerMode$Changing: ClusterEvents.AttributeObservable<Attribute<ElectricalPowerMeasurement.PowerMode, any>>;
} & {
    activeCurrent$Changing: undefined | ClusterEvents.AttributeObservable<OptionalAttribute<null | number | bigint, any>>;
    ranges$Changing: undefined | ClusterEvents.AttributeObservable<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>>;
    voltage$Changing: undefined | ClusterEvents.AttributeObservable<OptionalAttribute<null | number | bigint, any>>;
} & {
    accuracy$Changed: ClusterEvents.AttributeObservable<FixedAttribute<TypeFromFields<{
        accuracyRanges: FieldType<TypeFromFields<{
            fixedMax: ...;
            fixedMin: ...;
            fixedTypical: ...;
            percentMax: ...;
            percentMin: ...;
            percentTypical: ...;
            rangeMax: ...;
            rangeMin: ...;
        }>[]>;
        maxMeasuredValue: FieldType<number | bigint>;
        measured: FieldType<boolean>;
        measurementType: FieldType<MeasurementType>;
        minMeasuredValue: FieldType<number | bigint>;
    }>[], any>>;
    activePower$Changed: ClusterEvents.AttributeObservable<Attribute<null | number | bigint, any>>;
    numberOfMeasurementTypes$Changed: ClusterEvents.AttributeObservable<FixedAttribute<number, any>>;
    powerMode$Changed: ClusterEvents.AttributeObservable<Attribute<ElectricalPowerMeasurement.PowerMode, any>>;
} & {
    activeCurrent$Changed: undefined | ClusterEvents.AttributeObservable<OptionalAttribute<null | number | bigint, any>>;
    ranges$Changed: undefined | ClusterEvents.AttributeObservable<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>>;
    voltage$Changed: undefined | ClusterEvents.AttributeObservable<OptionalAttribute<null | number | bigint, any>>;
} & {} & {
    measurementPeriodRanges?: ClusterEvents.EventObservable<OptionalEvent<TypeFromFields<{
        ranges: FieldType<TypeFromFields<{
            endSystime: ...;
            endTimestamp: ...;
            max: ...;
            maxSystime: ...;
            maxTimestamp: ...;
            measurementType: ...;
            min: ...;
            minSystime: ...;
            minTimestamp: ...;
            startSystime: ...;
            startTimestamp: ...;
        }>[]>;
    }>, any>>;
}

Access the behavior's events.

Type declaration

Optional ReadonlymeasurementPeriodRanges?: ClusterEvents.EventObservable<OptionalEvent<TypeFromFields<{
    ranges: FieldType<TypeFromFields<{
        endSystime: ...;
        endTimestamp: ...;
        max: ...;
        maxSystime: ...;
        maxTimestamp: ...;
        measurementType: ...;
        min: ...;
        minSystime: ...;
        minTimestamp: ...;
        startSystime: ...;
        startTimestamp: ...;
    }>[]>;
}>, any>>
If supported, this event shall be generated at the end of a measurement period. The start and end times for measurement periods shall be determined by the server, and may represent overlapping periods.

See
MatterSpecification.v13.Cluster § 2.13.7.1

features

features: TypeFromBitSchema<{
    alternatingCurrent: BitFlag;
    directCurrent: BitFlag;
    harmonics: BitFlag;
    polyphasePower: BitFlag;
    powerQuality: BitFlag;
}>

Supported features as a flag object.

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

session

session: SecureSession

`Readonly`state

state: Omit<{}, never> & {
    activePower: null | number | bigint;
    powerMode: ElectricalPowerMeasurement.PowerMode;
} & {
    activeCurrent?: null | number | bigint;
    ranges?: 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>;
    }>[];
    voltage?: null | number | bigint;
} & {
    accuracy: TypeFromFields<{
        accuracyRanges: FieldType<TypeFromFields<{
            fixedMax: OptionalFieldType<(...) | (...)>;
            fixedMin: OptionalFieldType<(...) | (...)>;
            fixedTypical: OptionalFieldType<(...) | (...)>;
            percentMax: OptionalFieldType<number>;
            percentMin: OptionalFieldType<number>;
            percentTypical: OptionalFieldType<number>;
            rangeMax: FieldType<(...) | (...)>;
            rangeMin: FieldType<(...) | (...)>;
        }>[]>;
        maxMeasuredValue: FieldType<number | bigint>;
        measured: FieldType<boolean>;
        measurementType: FieldType<MeasurementType>;
        minMeasuredValue: FieldType<number | bigint>;
    }>[];
    numberOfMeasurementTypes: number;
} & {}

Access the behavior's state.

Type declaration

ReadonlyactivePower: null | number | bigint
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
ReadonlypowerMode: ElectricalPowerMeasurement.PowerMode
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

Type declaration

Optional ReadonlyactiveCurrent?: null | number | bigint
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
Optional Readonlyranges?: 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>;
}>[]
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
Optional Readonlyvoltage?: null | number | bigint
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

Type declaration

Readonlyaccuracy: TypeFromFields<{
    accuracyRanges: FieldType<TypeFromFields<{
        fixedMax: OptionalFieldType<(...) | (...)>;
        fixedMin: OptionalFieldType<(...) | (...)>;
        fixedTypical: OptionalFieldType<(...) | (...)>;
        percentMax: OptionalFieldType<number>;
        percentMin: OptionalFieldType<number>;
        percentTypical: OptionalFieldType<number>;
        rangeMax: FieldType<(...) | (...)>;
        rangeMin: FieldType<(...) | (...)>;
    }>[]>;
    maxMeasuredValue: FieldType<number | bigint>;
    measured: FieldType<boolean>;
    measurementType: FieldType<MeasurementType>;
    minMeasuredValue: FieldType<number | bigint>;
}>[]
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
ReadonlynumberOfMeasurementTypes: number
This shall indicate the maximum number of measurement types the server is capable of reporting.

See
MatterSpecification.v13.Cluster § 2.13.6.2

`Static` `Readonly`cluster

cluster: Of<{
    attributes: {
        accuracy: FixedAttribute<TypeFromFields<{
            accuracyRanges: FieldType<TypeFromFields<{
                fixedMax: ...;
                fixedMin: ...;
                fixedTypical: ...;
                percentMax: ...;
                percentMin: ...;
                percentTypical: ...;
                rangeMax: ...;
                rangeMin: ...;
            }>[]>;
            maxMeasuredValue: FieldType<number | bigint>;
            measured: FieldType<boolean>;
            measurementType: FieldType<MeasurementType>;
            minMeasuredValue: FieldType<number | bigint>;
        }>[], any>;
        activeCurrent: OptionalAttribute<null | number | bigint, any>;
        activePower: Attribute<null | number | bigint, any>;
        numberOfMeasurementTypes: FixedAttribute<number, any>;
        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>;
        voltage: OptionalAttribute<null | number | bigint, any>;
    };
    events: {
        measurementPeriodRanges: OptionalEvent<TypeFromFields<{
            ranges: FieldType<TypeFromFields<{
                endSystime: OptionalFieldType<(...)>;
                endTimestamp: OptionalFieldType<(...)>;
                max: FieldType<(...)>;
                maxSystime: OptionalFieldType<(...)>;
                maxTimestamp: OptionalFieldType<(...)>;
                measurementType: FieldType<(...)>;
                min: FieldType<(...)>;
                minSystime: OptionalFieldType<(...)>;
                minTimestamp: OptionalFieldType<(...)>;
                startSystime: OptionalFieldType<(...)>;
                startTimestamp: OptionalFieldType<(...)>;
            }>[]>;
        }>, any>;
    };
    extensions: readonly [{
        component: {
            attributes: {
                apparentCurrent: OptionalAttribute<null | number | bigint, any>;
                apparentPower: OptionalAttribute<null | number | bigint, any>;
                frequency: OptionalAttribute<null | number | bigint, any>;
                powerFactor: OptionalAttribute<null | number | bigint, any>;
                reactiveCurrent: OptionalAttribute<null | number | bigint, any>;
                reactivePower: OptionalAttribute<null | number | bigint, any>;
                rmsCurrent: OptionalAttribute<null | number | bigint, any>;
                rmsPower: OptionalAttribute<null | number | bigint, any>;
                rmsVoltage: OptionalAttribute<null | number | bigint, any>;
            };
        };
        flags: {
            alternatingCurrent: true;
        };
    }, {
        component: {
            attributes: {
                harmonicCurrents: Attribute<null | TypeFromFields<{
                    measurement: ...;
                    order: ...;
                }>[], any>;
            };
        };
        flags: {
            harmonics: true;
        };
    }, {
        component: {
            attributes: {
                harmonicPhases: Attribute<null | TypeFromFields<{
                    measurement: ...;
                    order: ...;
                }>[], any>;
            };
        };
        flags: {
            powerQuality: true;
        };
    }, {
        component: {
            attributes: {
                neutralCurrent: OptionalAttribute<null | number | bigint, any>;
            };
        };
        flags: {
            polyphasePower: true;
        };
    }, {
        component: false;
        flags: {
            alternatingCurrent: false;
            polyphasePower: true;
        };
    }, {
        component: false;
        flags: {
            alternatingCurrent: false;
            harmonics: true;
        };
    }, {
        component: false;
        flags: {
            alternatingCurrent: false;
            powerQuality: true;
        };
    }, {
        component: false;
        flags: {
            alternatingCurrent: false;
            directCurrent: false;
        };
    }];
    features: {
        alternatingCurrent: BitFlag;
        directCurrent: BitFlag;
        harmonics: BitFlag;
        polyphasePower: BitFlag;
        powerQuality: BitFlag;
    };
    id: 144;
    name: "ElectricalPowerMeasurement";
    revision: 1;
}>

Base cluster state include all attribute values but may be extended by subclasses.

Type declaration

Readonlyattributes: {
    accuracy: FixedAttribute<TypeFromFields<{
        accuracyRanges: FieldType<TypeFromFields<{
            fixedMax: ...;
            fixedMin: ...;
            fixedTypical: ...;
            percentMax: ...;
            percentMin: ...;
            percentTypical: ...;
            rangeMax: ...;
            rangeMin: ...;
        }>[]>;
        maxMeasuredValue: FieldType<number | bigint>;
        measured: FieldType<boolean>;
        measurementType: FieldType<MeasurementType>;
        minMeasuredValue: FieldType<number | bigint>;
    }>[], any>;
    activeCurrent: OptionalAttribute<null | number | bigint, any>;
    activePower: Attribute<null | number | bigint, any>;
    numberOfMeasurementTypes: FixedAttribute<number, any>;
    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>;
    voltage: OptionalAttribute<null | number | bigint, any>;
}
- Readonlyaccuracy: FixedAttribute<TypeFromFields<{
      accuracyRanges: FieldType<TypeFromFields<{
          fixedMax: ...;
          fixedMin: ...;
          fixedTypical: ...;
          percentMax: ...;
          percentMin: ...;
          percentTypical: ...;
          rangeMax: ...;
          rangeMin: ...;
      }>[]>;
      maxMeasuredValue: FieldType<number | bigint>;
      measured: FieldType<boolean>;
      measurementType: FieldType<MeasurementType>;
      minMeasuredValue: FieldType<number | bigint>;
  }>[], any>
  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
- 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
- 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
- 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
Readonlyevents: {
    measurementPeriodRanges: OptionalEvent<TypeFromFields<{
        ranges: FieldType<TypeFromFields<{
            endSystime: OptionalFieldType<(...)>;
            endTimestamp: OptionalFieldType<(...)>;
            max: FieldType<(...)>;
            maxSystime: OptionalFieldType<(...)>;
            maxTimestamp: OptionalFieldType<(...)>;
            measurementType: FieldType<(...)>;
            min: FieldType<(...)>;
            minSystime: OptionalFieldType<(...)>;
            minTimestamp: OptionalFieldType<(...)>;
            startSystime: OptionalFieldType<(...)>;
            startTimestamp: OptionalFieldType<(...)>;
        }>[]>;
    }>, any>;
}
- ReadonlymeasurementPeriodRanges: OptionalEvent<TypeFromFields<{
      ranges: FieldType<TypeFromFields<{
          endSystime: OptionalFieldType<(...)>;
          endTimestamp: OptionalFieldType<(...)>;
          max: FieldType<(...)>;
          maxSystime: OptionalFieldType<(...)>;
          maxTimestamp: OptionalFieldType<(...)>;
          measurementType: FieldType<(...)>;
          min: FieldType<(...)>;
          minSystime: OptionalFieldType<(...)>;
          minTimestamp: OptionalFieldType<(...)>;
          startSystime: OptionalFieldType<(...)>;
          startTimestamp: OptionalFieldType<(...)>;
      }>[]>;
  }>, any>
  If supported, this event shall be generated at the end of a measurement period. The start and end times for measurement periods shall be determined by the server, and may represent overlapping periods.
  
  See
  MatterSpecification.v13.Cluster § 2.13.7.1
Readonlyextensions: readonly [{
    component: {
        attributes: {
            apparentCurrent: OptionalAttribute<null | number | bigint, any>;
            apparentPower: OptionalAttribute<null | number | bigint, any>;
            frequency: OptionalAttribute<null | number | bigint, any>;
            powerFactor: OptionalAttribute<null | number | bigint, any>;
            reactiveCurrent: OptionalAttribute<null | number | bigint, any>;
            reactivePower: OptionalAttribute<null | number | bigint, any>;
            rmsCurrent: OptionalAttribute<null | number | bigint, any>;
            rmsPower: OptionalAttribute<null | number | bigint, any>;
            rmsVoltage: OptionalAttribute<null | number | bigint, any>;
        };
    };
    flags: {
        alternatingCurrent: true;
    };
}, {
    component: {
        attributes: {
            harmonicCurrents: Attribute<null | TypeFromFields<{
                measurement: ...;
                order: ...;
            }>[], any>;
        };
    };
    flags: {
        harmonics: true;
    };
}, {
    component: {
        attributes: {
            harmonicPhases: Attribute<null | TypeFromFields<{
                measurement: ...;
                order: ...;
            }>[], any>;
        };
    };
    flags: {
        powerQuality: true;
    };
}, {
    component: {
        attributes: {
            neutralCurrent: OptionalAttribute<null | number | bigint, any>;
        };
    };
    flags: {
        polyphasePower: true;
    };
}, {
    component: false;
    flags: {
        alternatingCurrent: false;
        polyphasePower: true;
    };
}, {
    component: false;
    flags: {
        alternatingCurrent: false;
        harmonics: true;
    };
}, {
    component: false;
    flags: {
        alternatingCurrent: false;
        powerQuality: true;
    };
}, {
    component: false;
    flags: {
        alternatingCurrent: false;
        directCurrent: false;
    };
}]
This metadata controls which ElectricalPowerMeasurementCluster elements matter.js activates for specific feature combinations.
Readonlyfeatures: {
    alternatingCurrent: BitFlag;
    directCurrent: BitFlag;
    harmonics: BitFlag;
    polyphasePower: BitFlag;
    powerQuality: BitFlag;
}
- 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
Readonlyid: 144
Readonlyname: "ElectricalPowerMeasurement"
Readonlyrevision: 1

`Static` `Readonly`defaults

defaults: ClusterState.Type<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>;
        numberOfMeasurementTypes: FixedAttribute<number, any>;
        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>;
        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>;
    };
    extensions: readonly [{
        component: {
            attributes: {
                apparentCurrent: OptionalAttribute<null | number | bigint, any>;
                apparentPower: OptionalAttribute<null | number | bigint, any>;
                frequency: OptionalAttribute<null | number | bigint, any>;
                powerFactor: OptionalAttribute<null | number | bigint, any>;
                reactiveCurrent: OptionalAttribute<null | number | bigint, any>;
                reactivePower: OptionalAttribute<null | number | bigint, any>;
                rmsCurrent: OptionalAttribute<null | number | bigint, any>;
                rmsPower: OptionalAttribute<null | number | bigint, any>;
                rmsVoltage: OptionalAttribute<null | number | bigint, any>;
            };
        };
        flags: {
            alternatingCurrent: true;
        };
    }, {
        component: {
            attributes: {
                harmonicCurrents: Attribute<null | TypeFromFields<(...)>[], any>;
            };
        };
        flags: {
            harmonics: true;
        };
    }, {
        component: {
            attributes: {
                harmonicPhases: Attribute<null | TypeFromFields<(...)>[], any>;
            };
        };
        flags: {
            powerQuality: true;
        };
    }, {
        component: {
            attributes: {
                neutralCurrent: OptionalAttribute<null | number | bigint, any>;
            };
        };
        flags: {
            polyphasePower: true;
        };
    }, {
        component: false;
        flags: {
            alternatingCurrent: false;
            polyphasePower: true;
        };
    }, {
        component: false;
        flags: {
            alternatingCurrent: false;
            harmonics: true;
        };
    }, {
        component: false;
        flags: {
            alternatingCurrent: false;
            powerQuality: true;
        };
    }, {
        component: false;
        flags: {
            alternatingCurrent: false;
            directCurrent: false;
        };
    }];
    features: {
        alternatingCurrent: BitFlag;
        directCurrent: BitFlag;
        harmonics: BitFlag;
        polyphasePower: BitFlag;
        powerQuality: BitFlag;
    };
    id: 144;
    name: "ElectricalPowerMeasurement";
    revision: 1;
}>, typeof ClusterBehavior>

`Static` `Optional` `Readonly`dependencies

dependencies?: Iterable<Type, any, any>

`Static` `Readonly`early

early: boolean

`Static` `Readonly`Events

Events: ClusterEvents.Type<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>;
        numberOfMeasurementTypes: FixedAttribute<number, any>;
        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>;
        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>;
    };
    extensions: readonly [{
        component: {
            attributes: {
                apparentCurrent: OptionalAttribute<null | number | bigint, any>;
                apparentPower: OptionalAttribute<null | number | bigint, any>;
                frequency: OptionalAttribute<null | number | bigint, any>;
                powerFactor: OptionalAttribute<null | number | bigint, any>;
                reactiveCurrent: OptionalAttribute<null | number | bigint, any>;
                reactivePower: OptionalAttribute<null | number | bigint, any>;
                rmsCurrent: OptionalAttribute<null | number | bigint, any>;
                rmsPower: OptionalAttribute<null | number | bigint, any>;
                rmsVoltage: OptionalAttribute<null | number | bigint, any>;
            };
        };
        flags: {
            alternatingCurrent: true;
        };
    }, {
        component: {
            attributes: {
                harmonicCurrents: Attribute<null | TypeFromFields<(...)>[], any>;
            };
        };
        flags: {
            harmonics: true;
        };
    }, {
        component: {
            attributes: {
                harmonicPhases: Attribute<null | TypeFromFields<(...)>[], any>;
            };
        };
        flags: {
            powerQuality: true;
        };
    }, {
        component: {
            attributes: {
                neutralCurrent: OptionalAttribute<null | number | bigint, any>;
            };
        };
        flags: {
            polyphasePower: true;
        };
    }, {
        component: false;
        flags: {
            alternatingCurrent: false;
            polyphasePower: true;
        };
    }, {
        component: false;
        flags: {
            alternatingCurrent: false;
            harmonics: true;
        };
    }, {
        component: false;
        flags: {
            alternatingCurrent: false;
            powerQuality: true;
        };
    }, {
        component: false;
        flags: {
            alternatingCurrent: false;
            directCurrent: false;
        };
    }];
    features: {
        alternatingCurrent: BitFlag;
        directCurrent: BitFlag;
        harmonics: BitFlag;
        polyphasePower: BitFlag;
        powerQuality: BitFlag;
    };
    id: 144;
    name: "ElectricalPowerMeasurement";
    revision: 1;
}>, typeof ClusterBehavior>

`Static` `Readonly`ExtensionInterface

ExtensionInterface: {}

`Static` `Readonly`id

The behavior ID for ClusterBehaviors is the name of the cluster.

`Static` `Readonly`Interface

Interface: {
components: never[];
}

`Static` `Readonly`Internal

Internal: (new () => {})

`Static` `Readonly`name

name: string

`Static` `Optional` `Readonly`schema

schema?: Schema

`Static` `Readonly`State

State: (new () => ClusterState.Type<Of<{
    attributes: {
        accuracy: FixedAttribute<TypeFromFields<{
            accuracyRanges: FieldType<(...)[]>;
            maxMeasuredValue: FieldType<(...) | (...)>;
            measured: FieldType<boolean>;
            measurementType: FieldType<MeasurementType>;
            minMeasuredValue: FieldType<(...) | (...)>;
        }>[], any>;
        activeCurrent: OptionalAttribute<null | number | bigint, any>;
        activePower: Attribute<null | number | bigint, any>;
        numberOfMeasurementTypes: FixedAttribute<number, any>;
        powerMode: Attribute<ElectricalPowerMeasurement.PowerMode, any>;
        ranges: OptionalAttribute<TypeFromFields<{
            endSystime: OptionalFieldType<(...) | (...)>;
            endTimestamp: OptionalFieldType<number>;
            max: FieldType<(...) | (...)>;
            maxSystime: OptionalFieldType<(...) | (...)>;
            maxTimestamp: OptionalFieldType<number>;
            measurementType: FieldType<MeasurementType>;
            min: FieldType<(...) | (...)>;
            minSystime: OptionalFieldType<(...) | (...)>;
            minTimestamp: OptionalFieldType<number>;
            startSystime: OptionalFieldType<(...) | (...)>;
            startTimestamp: OptionalFieldType<number>;
        }>[], any>;
        voltage: OptionalAttribute<null | number | bigint, any>;
    };
    events: {
        measurementPeriodRanges: OptionalEvent<TypeFromFields<{
            ranges: FieldType<TypeFromFields<(...)>[]>;
        }>, any>;
    };
    extensions: readonly [{
        component: {
            attributes: {
                apparentCurrent: OptionalAttribute<null | number | bigint, any>;
                apparentPower: OptionalAttribute<null | number | bigint, any>;
                frequency: OptionalAttribute<null | number | bigint, any>;
                powerFactor: OptionalAttribute<null | number | bigint, any>;
                reactiveCurrent: OptionalAttribute<null | number | bigint, any>;
                reactivePower: OptionalAttribute<null | number | bigint, any>;
                rmsCurrent: OptionalAttribute<null | number | bigint, any>;
                rmsPower: OptionalAttribute<null | number | bigint, any>;
                rmsVoltage: OptionalAttribute<null | number | bigint, any>;
            };
        };
        flags: {
            alternatingCurrent: true;
        };
    }, {
        component: {
            attributes: {
                harmonicCurrents: Attribute<null | (...)[], any>;
            };
        };
        flags: {
            harmonics: true;
        };
    }, {
        component: {
            attributes: {
                harmonicPhases: Attribute<null | (...)[], any>;
            };
        };
        flags: {
            powerQuality: true;
        };
    }, {
        component: {
            attributes: {
                neutralCurrent: OptionalAttribute<null | number | bigint, any>;
            };
        };
        flags: {
            polyphasePower: true;
        };
    }, {
        component: false;
        flags: {
            alternatingCurrent: false;
            polyphasePower: true;
        };
    }, {
        component: false;
        flags: {
            alternatingCurrent: false;
            harmonics: true;
        };
    }, {
        component: false;
        flags: {
            alternatingCurrent: false;
            powerQuality: true;
        };
    }, {
        component: false;
        flags: {
            alternatingCurrent: false;
            directCurrent: false;
        };
    }];
    features: {
        alternatingCurrent: BitFlag;
        directCurrent: BitFlag;
        harmonics: BitFlag;
        polyphasePower: BitFlag;
        powerQuality: BitFlag;
    };
    id: 144;
    name: "ElectricalPowerMeasurement";
    revision: 1;
}>, typeof ClusterBehavior>)

`Static` `Readonly`supervisor

supervisor: RootSupervisor

`Static`supports

supports: ((other: Type) => boolean)

Type declaration

- (other): boolean
- Does this behavior support functionality of a specific implementation?
  Parameters
  - other: Type
  Returns boolean

Methods

[asyncDispose]

[asyncDispose](): MaybePromise
Release resources. This is the public API for releasing application resources held by behaviors in internal state.

Returns MaybePromise
Inherited from ElectricalPowerMeasurementBehavior.[asyncDispose]
- Defined in packages/node/src/behavior/Behavior.ts:206

asAdmin

asAdmin(fn): void
Parameters
- fn: (() => void)
  the elevated logic
  - - (): void
    - Returns void
Returns void
Inherited from ElectricalPowerMeasurementBehavior.asAdmin
- Defined in packages/node/src/behavior/Behavior.ts:135

assertAttributeEnabled

assertAttributeEnabled<This, K>(this, attributeName): void
Type Parameters
- This extends Behavior
- K extends string | number | symbol
Parameters
- this: This
- attributeName: K
Returns void
Inherited from ElectricalPowerMeasurementBehavior.assertAttributeEnabled
- Defined in packages/node/src/behavior/cluster/ClusterBehavior.ts:180

`Protected`callback

callback<A, R>(reactor, options?): ((...args: A) => undefined | R)
Create a generic callback function that has the same properties as a Reactor.

Like a reactor, the callback's "this" will be bound to an active Behavior instance. Because of this: The reactor MUST be a real JS function - arrow functions will not work!
Type Parameters
- A extends any[]
- R
Parameters
- reactor: Reactor<A, R>
- Optionaloptions: Reactor.Options
Returns ((...args: A) => undefined | R)
- - (...args): undefined | R
  - Parameters
    - Rest...args: A
    Returns undefined | R
Inherited from ElectricalPowerMeasurementBehavior.callback
- Defined in packages/node/src/behavior/Behavior.ts:234

initialize

initialize(_options?): MaybePromise
Behaviors are ephemeral and should not perform initialization in their constructor. They can override this method instead.

This method may be synchronous or asyncronous. If asynchronous, the behavior will not be available for external use until initialization completes.
Parameters
- Optional_options: {}
Returns MaybePromise
Inherited from ElectricalPowerMeasurementBehavior.initialize
- Defined in packages/node/src/behavior/Behavior.ts:200

`Protected`reactTo

reactTo<O>(observable, reactor, options?): void
Install a Reactor.

Important: The reactor MUST be a real JS function - arrow functions will not work!
Type Parameters
- O extends Observable<any[], any>
Parameters
- observable: O
- reactor: Reactor<Parameters<O["emit"]>, ReturnType<O["emit"]>>
- Optionaloptions: Reactor.Options
Returns void
Inherited from ElectricalPowerMeasurementBehavior.reactTo
- Defined in packages/node/src/behavior/Behavior.ts:220

requireAttributeEnabled

requireAttributeEnabled<This, K>(this, attributeName): Exclude<This["state"][K], undefined>
Type Parameters
- This extends Behavior
- K extends string | number | symbol
Parameters
- this: This
- attributeName: K
Returns Exclude<This["state"][K], undefined>
Inherited from ElectricalPowerMeasurementBehavior.requireAttributeEnabled
- Defined in packages/node/src/behavior/cluster/ClusterBehavior.ts:168

toString

toString(): string
Returns string
Inherited from ElectricalPowerMeasurementBehavior.toString
- Defined in packages/node/src/behavior/Behavior.ts:211

`Static`alter

alter<This, const AlterationsT>(this, alterations): Type<WithAlterations<This["cluster"], AlterationsT>, This, ClusterInterface.InterfaceOf<This>>
Type Parameters
- This extends Type<ClusterType, Type, ClusterInterface<{}>>
- const AlterationsT extends Alterations<This["cluster"]>
Parameters
- this: This
- alterations: AlterationsT
Returns Type<WithAlterations<This["cluster"], AlterationsT>, This, ClusterInterface.InterfaceOf<This>>
Inherited from ElectricalPowerMeasurementBehavior.alter
- Defined in packages/node/src/behavior/cluster/ClusterBehavior.ts:251

`Static`enable

enable<This, const FlagsT>(this, flags): Type<WithAlterations<This["cluster"], ElementFlagAlterations<FlagsT>>, This, ClusterInterface.InterfaceOf<This>>
Type Parameters
- This extends Type<ClusterType, Type, ClusterInterface<{}>>
- const FlagsT extends ElementFlags<This["cluster"]>
Parameters
- this: This
- flags: FlagsT
Returns Type<WithAlterations<This["cluster"], ElementFlagAlterations<FlagsT>>, This, ClusterInterface.InterfaceOf<This>>
Inherited from ElectricalPowerMeasurementBehavior.enable
- Defined in packages/node/src/behavior/cluster/ClusterBehavior.ts:261

`Static`for

for<This, const ClusterT>(this, cluster, schema?): Type<ClusterT, This, ClusterInterface.InterfaceOf<This>>
Type Parameters
- This extends Type<ClusterType, Type, ClusterInterface<{}>>
- const ClusterT extends ClusterType
Parameters
- this: This
- cluster: ClusterT
- Optionalschema: Schema
Returns Type<ClusterT, This, ClusterInterface.InterfaceOf<This>>
Inherited from ElectricalPowerMeasurementBehavior.for
- Defined in packages/node/src/behavior/cluster/ClusterBehavior.ts:237

`Static`set

set<This>(this, defaults): This
Type Parameters
- This extends Type
Parameters
- this: This
- defaults: Partial<RelaxTypes<InstanceType<This["State"]>>>
Returns This
Inherited from ElectricalPowerMeasurementBehavior.set
- Defined in packages/node/src/behavior/cluster/ClusterBehavior.ts:259

`Static`with

with<This, const FeaturesT>(this, ...features): Type<WithFeatures<This["cluster"], FeaturesT>, This, ClusterInterface.InterfaceOf<This>>
Type Parameters
- This extends Type<ClusterType, Type, ClusterInterface<{}>>
- const FeaturesT extends FeatureSelection<This["cluster"]>
Parameters
- this: This
- Rest...features: FeaturesT
Returns Type<WithFeatures<This["cluster"], FeaturesT>, This, ClusterInterface.InterfaceOf<This>>
Inherited from ElectricalPowerMeasurementBehavior.with
- Defined in packages/node/src/behavior/cluster/ClusterBehavior.ts:243

Class ElectricalPowerMeasurementServer

Hierarchy (view full)

Index

Constructors

Properties

Methods

Constructors

constructor

Parameters

Returns ElectricalPowerMeasurementServer

Properties

[reference]

agent

cluster

context

endpoint

env

Readonlyevents

Type declaration

See

features

Type declaration

ReadonlyalternatingCurrent: BitFlag

See

ReadonlydirectCurrent: BitFlag

See

Readonlyharmonics: BitFlag

See

ReadonlypolyphasePower: BitFlag

See

ReadonlypowerQuality: BitFlag

See

session

Readonlystate

Type declaration

ReadonlyactivePower: null | number | bigint

See

ReadonlypowerMode: ElectricalPowerMeasurement.PowerMode

See

Type declaration

Optional ReadonlyactiveCurrent?: null | number | bigint

See

See

Optional Readonlyvoltage?: null | number | bigint

See

Type declaration

See

ReadonlynumberOfMeasurementTypes: number

See

Static Readonlycluster

Type declaration

See

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

See

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

See

ReadonlynumberOfMeasurementTypes: FixedAttribute<number, any>

See

ReadonlypowerMode: Attribute<ElectricalPowerMeasurement.PowerMode, any>

See

See

Readonlyvoltage: OptionalAttribute<null | number | bigint, any>

See

See

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

ReadonlyalternatingCurrent: BitFlag

See

ReadonlydirectCurrent: BitFlag

See

Readonlyharmonics: BitFlag

See

ReadonlypolyphasePower: BitFlag

See

ReadonlypowerQuality: BitFlag

See

Readonlyid: 144

Readonlyname: "ElectricalPowerMeasurement"

Readonlyrevision: 1

Static Readonlydefaults

Static Optional Readonlydependencies

`Readonly`events

`Readonly`alternatingCurrent: BitFlag

`Readonly`directCurrent: BitFlag

`Readonly`harmonics: BitFlag

`Readonly`polyphasePower: BitFlag

`Readonly`powerQuality: BitFlag

`Readonly`state

`Readonly`activePower: null | number | bigint

`Readonly`powerMode: ElectricalPowerMeasurement.PowerMode

`Optional` `Readonly`activeCurrent?: null | number | bigint

`Optional` `Readonly`voltage?: null | number | bigint

`Readonly`numberOfMeasurementTypes: number

`Static` `Readonly`cluster

`Readonly`activeCurrent: OptionalAttribute<null | number | bigint, any>

`Readonly`activePower: Attribute<null | number | bigint, any>

`Readonly`numberOfMeasurementTypes: FixedAttribute<number, any>

`Readonly`powerMode: Attribute<ElectricalPowerMeasurement.PowerMode, any>

`Readonly`voltage: OptionalAttribute<null | number | bigint, any>

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

`Readonly`alternatingCurrent: BitFlag

`Readonly`directCurrent: BitFlag

`Readonly`harmonics: BitFlag

`Readonly`polyphasePower: BitFlag

`Readonly`powerQuality: BitFlag

`Readonly`id: 144

`Readonly`name: "ElectricalPowerMeasurement"

`Readonly`revision: 1

`Static` `Readonly`defaults

`Static` `Optional` `Readonly`dependencies

`Static` `Readonly`early

`Static` `Readonly`Events

`Static` `Readonly`ExtensionInterface

`Static` `Readonly`id

`Static` `Readonly`Interface

`Static` `Readonly`Internal

`Static` `Readonly`name

`Static` `Optional` `Readonly`schema

`Static` `Readonly`State

`Static` `Readonly`supervisor

`Static`supports

`Protected`callback

`Protected`reactTo

`Static`alter

`Static`enable

`Static`for

`Static`set

`Static`with