Variable CompleteInstanceConst

CompleteInstance: MutableCluster<{
    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>;
        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<number>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                harmonics: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        harmonicPhases: Attribute<null | TypeFromFields<{
            measurement: FieldType<(...) | (...) | (...)>;
            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>;
    };
    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>;
    };
    features: {
        alternatingCurrent: BitFlag;
        directCurrent: BitFlag;
        harmonics: BitFlag;
        polyphasePower: BitFlag;
        powerQuality: BitFlag;
    };
    id: 144;
    name: "ElectricalPowerMeasurement";
    revision: 1;
}, []> = ...

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>;
        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<number>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                harmonics: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        harmonicPhases: Attribute<null | TypeFromFields<{
            measurement: FieldType<(...) | (...) | (...)>;
            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>;
    }
    • 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

    • 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<(...) | (...) | (...)>;
          order: FieldType<number>;
      }>[], any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              harmonics: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList<BitSchema>;
      }
    • ReadonlyharmonicPhases: Attribute<null | TypeFromFields<{
          measurement: FieldType<(...) | (...) | (...)>;
          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

  • 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>;
    }
  • 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

See

Complete

Settings

Member Visibility