Class ElectricalEnergyMeasurementServer

Hierarchy

  • ClusterBehavior<this> & Omit<ElectricalEnergyMeasurementServerLogic,
        | "events"
        | "cluster"
        | "state"
        | "initialize"
        | typeof asyncDispose
        | "setMeasurement"> & Omit<{} & {}, never> & {
        setMeasurement(measurement: AtomicElectricalEnergyMeasurement): void;
    } & {
        cluster: Of<{
            attributes: {
                accuracy: FixedAttribute<TypeFromFields<{
                    accuracyRanges: FieldType<(...)[]>;
                    maxMeasuredValue: FieldType<(...) | (...)>;
                    measured: FieldType<boolean>;
                    measurementType: FieldType<MeasurementType>;
                    minMeasuredValue: FieldType<(...) | (...)>;
                }>, any>;
            };
            extensions: readonly [{
                component: {
                    attributes: {
                        cumulativeEnergyImported: Attribute<(...) | (...), any>;
                    };
                };
                flags: {
                    cumulativeEnergy: true;
                    importedEnergy: true;
                };
            }, {
                component: {
                    attributes: {
                        cumulativeEnergyExported: Attribute<(...) | (...), any>;
                    };
                };
                flags: {
                    cumulativeEnergy: true;
                    exportedEnergy: true;
                };
            }, {
                component: {
                    attributes: {
                        periodicEnergyImported: Attribute<(...) | (...), any>;
                    };
                };
                flags: {
                    importedEnergy: true;
                    periodicEnergy: true;
                };
            }, {
                component: {
                    attributes: {
                        periodicEnergyExported: Attribute<(...) | (...), any>;
                    };
                };
                flags: {
                    exportedEnergy: true;
                    periodicEnergy: true;
                };
            }, {
                component: {
                    attributes: {
                        cumulativeEnergyReset: OptionalAttribute<(...) | (...), any>;
                    };
                    events: {
                        cumulativeEnergyMeasured: Event<TypeFromFields<(...)>, any>;
                    };
                };
                flags: {
                    cumulativeEnergy: true;
                };
            }, {
                component: {
                    events: {
                        periodicEnergyMeasured: Event<TypeFromFields<(...)>, any>;
                    };
                };
                flags: {
                    periodicEnergy: true;
                };
            }, {
                component: false;
                flags: {
                    exportedEnergy: false;
                    importedEnergy: false;
                };
            }, {
                component: false;
                flags: {
                    cumulativeEnergy: false;
                    periodicEnergy: false;
                };
            }];
            features: {
                cumulativeEnergy: BitFlag;
                exportedEnergy: BitFlag;
                importedEnergy: BitFlag;
                periodicEnergy: BitFlag;
            };
            id: 145;
            name: "ElectricalEnergyMeasurement";
            revision: 1;
        }>;
        events: ClusterEvents<Of<{
            attributes: {
                accuracy: FixedAttribute<TypeFromFields<{
                    accuracyRanges: FieldType<(...)>;
                    maxMeasuredValue: FieldType<(...)>;
                    measured: FieldType<(...)>;
                    measurementType: FieldType<(...)>;
                    minMeasuredValue: FieldType<(...)>;
                }>, any>;
            };
            extensions: readonly [{
                component: {
                    attributes: {
                        cumulativeEnergyImported: Attribute<(...), (...)>;
                    };
                };
                flags: {
                    cumulativeEnergy: true;
                    importedEnergy: true;
                };
            }, {
                component: {
                    attributes: {
                        cumulativeEnergyExported: Attribute<(...), (...)>;
                    };
                };
                flags: {
                    cumulativeEnergy: true;
                    exportedEnergy: true;
                };
            }, {
                component: {
                    attributes: {
                        periodicEnergyImported: Attribute<(...), (...)>;
                    };
                };
                flags: {
                    importedEnergy: true;
                    periodicEnergy: true;
                };
            }, {
                component: {
                    attributes: {
                        periodicEnergyExported: Attribute<(...), (...)>;
                    };
                };
                flags: {
                    exportedEnergy: true;
                    periodicEnergy: true;
                };
            }, {
                component: {
                    attributes: {
                        cumulativeEnergyReset: OptionalAttribute<(...), (...)>;
                    };
                    events: {
                        cumulativeEnergyMeasured: Event<(...), (...)>;
                    };
                };
                flags: {
                    cumulativeEnergy: true;
                };
            }, {
                component: {
                    events: {
                        periodicEnergyMeasured: Event<(...), (...)>;
                    };
                };
                flags: {
                    periodicEnergy: true;
                };
            }, {
                component: false;
                flags: {
                    exportedEnergy: false;
                    importedEnergy: false;
                };
            }, {
                component: false;
                flags: {
                    cumulativeEnergy: false;
                    periodicEnergy: false;
                };
            }];
            features: {
                cumulativeEnergy: BitFlag;
                exportedEnergy: BitFlag;
                importedEnergy: BitFlag;
                periodicEnergy: BitFlag;
            };
            id: 145;
            name: "ElectricalEnergyMeasurement";
            revision: 1;
        }>, typeof ElectricalEnergyMeasurementServerLogic>;
        features: TypeFromBitSchema<{
            cumulativeEnergy: BitFlag;
            exportedEnergy: BitFlag;
            importedEnergy: BitFlag;
            periodicEnergy: BitFlag;
        }>;
        state: ClusterState<Of<{
            attributes: {
                accuracy: FixedAttribute<TypeFromFields<{
                    accuracyRanges: FieldType<(...)>;
                    maxMeasuredValue: FieldType<(...)>;
                    measured: FieldType<(...)>;
                    measurementType: FieldType<(...)>;
                    minMeasuredValue: FieldType<(...)>;
                }>, any>;
            };
            extensions: readonly [{
                component: {
                    attributes: {
                        cumulativeEnergyImported: Attribute<(...), (...)>;
                    };
                };
                flags: {
                    cumulativeEnergy: true;
                    importedEnergy: true;
                };
            }, {
                component: {
                    attributes: {
                        cumulativeEnergyExported: Attribute<(...), (...)>;
                    };
                };
                flags: {
                    cumulativeEnergy: true;
                    exportedEnergy: true;
                };
            }, {
                component: {
                    attributes: {
                        periodicEnergyImported: Attribute<(...), (...)>;
                    };
                };
                flags: {
                    importedEnergy: true;
                    periodicEnergy: true;
                };
            }, {
                component: {
                    attributes: {
                        periodicEnergyExported: Attribute<(...), (...)>;
                    };
                };
                flags: {
                    exportedEnergy: true;
                    periodicEnergy: true;
                };
            }, {
                component: {
                    attributes: {
                        cumulativeEnergyReset: OptionalAttribute<(...), (...)>;
                    };
                    events: {
                        cumulativeEnergyMeasured: Event<(...), (...)>;
                    };
                };
                flags: {
                    cumulativeEnergy: true;
                };
            }, {
                component: {
                    events: {
                        periodicEnergyMeasured: Event<(...), (...)>;
                    };
                };
                flags: {
                    periodicEnergy: true;
                };
            }, {
                component: false;
                flags: {
                    exportedEnergy: false;
                    importedEnergy: false;
                };
            }, {
                component: false;
                flags: {
                    cumulativeEnergy: false;
                    periodicEnergy: false;
                };
            }];
            features: {
                cumulativeEnergy: BitFlag;
                exportedEnergy: BitFlag;
                importedEnergy: BitFlag;
                periodicEnergy: BitFlag;
            };
            id: 145;
            name: "ElectricalEnergyMeasurement";
            revision: 1;
        }>, typeof ElectricalEnergyMeasurementServerLogic>;
        [asyncDispose](): MaybePromise<void>;
    }
    • ElectricalEnergyMeasurementServer

Constructors

constructor

Properties

[reference] agent cluster context endpoint env events features session state cluster defaults dependencies? early Events ExtensionInterface id Interface Internal name schema? State supervisor supports

Methods

[asyncDispose] asAdmin assertAttributeEnabled callback initialize reactTo requireAttributeEnabled setMeasurement toString alter enable for set with

Constructors

constructor

Properties

[reference]

[reference]: Datasource<StateType>

agent

agent: Agent

cluster

cluster: never

The implemented cluster.

context

context: ActionContext

endpoint

endpoint: Endpoint<Empty>

env

env: Environment

Readonlyevents

events: EventEmitter & Omit<ClusterEvents<WithFeatures<ElectricalEnergyMeasurement.Complete, readonly [CumulativeEnergy, PeriodicEnergy, ImportedEnergy, ExportedEnergy]>, Type<ElectricalEnergyMeasurement.Complete, Type<Of<{
    attributes: {
        accuracy: FixedAttribute<TypeFromFields<{
            accuracyRanges: ...;
            maxMeasuredValue: ...;
            measured: ...;
            measurementType: ...;
            minMeasuredValue: ...;
        }>, any>;
    };
    extensions: readonly [{
        component: {
            attributes: {
                cumulativeEnergyImported: ...;
            };
        };
        flags: {
            cumulativeEnergy: true;
            importedEnergy: true;
        };
    }, {
        component: {
            attributes: {
                cumulativeEnergyExported: ...;
            };
        };
        flags: {
            cumulativeEnergy: true;
            exportedEnergy: true;
        };
    }, {
        component: {
            attributes: {
                periodicEnergyImported: ...;
            };
        };
        flags: {
            importedEnergy: true;
            periodicEnergy: true;
        };
    }, {
        component: {
            attributes: {
                periodicEnergyExported: ...;
            };
        };
        flags: {
            exportedEnergy: true;
            periodicEnergy: true;
        };
    }, {
        component: {
            attributes: {
                cumulativeEnergyReset: ...;
            };
            events: {
                cumulativeEnergyMeasured: ...;
            };
        };
        flags: {
            cumulativeEnergy: true;
        };
    }, {
        component: {
            events: {
                periodicEnergyMeasured: ...;
            };
        };
        flags: {
            periodicEnergy: true;
        };
    }, {
        component: false;
        flags: {
            exportedEnergy: false;
            importedEnergy: false;
        };
    }, {
        component: false;
        flags: {
            cumulativeEnergy: false;
            periodicEnergy: false;
        };
    }];
    features: {
        cumulativeEnergy: BitFlag;
        exportedEnergy: BitFlag;
        importedEnergy: BitFlag;
        periodicEnergy: BitFlag;
    };
    id: 145;
    name: "ElectricalEnergyMeasurement";
    revision: 1;
}>, typeof ClusterBehavior, {
    components: never[];
}>, {
    components: never[];
}>>,
    | "cumulativeEnergyMeasured"
    | "periodicEnergyMeasured"
    | "accuracy$Changing"
    | "accuracy$Changed"
    | "cumulativeEnergyImported$Changing"
    | "cumulativeEnergyExported$Changing"
    | "periodicEnergyImported$Changing"
    | "periodicEnergyExported$Changing"
    | "cumulativeEnergyReset$Changing"
    | "cumulativeEnergyImported$Changed"
    | "cumulativeEnergyExported$Changed"
    | "periodicEnergyImported$Changed"
    | "periodicEnergyExported$Changed"
    | "cumulativeEnergyReset$Changed"> & {
    accuracy$Changing: ClusterEvents.AttributeObservable<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>>;
} & {} & {
    accuracy$Changed: ClusterEvents.AttributeObservable<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>>;
} & {} & {} & {}

Access the behavior's events.

features

features: TypeFromBitSchema<{
    cumulativeEnergy: BitFlag;
    exportedEnergy: BitFlag;
    importedEnergy: BitFlag;
    periodicEnergy: BitFlag;
}> & TypeFromBitSchema<{
    cumulativeEnergy: BitFlag;
    exportedEnergy: BitFlag;
    importedEnergy: BitFlag;
    periodicEnergy: BitFlag;
}>

Supported features as a flag object.

session

session: SecureSession

Readonlystate

state: Omit<ClusterState.Type<WithFeatures<ElectricalEnergyMeasurement.Complete, readonly [CumulativeEnergy, PeriodicEnergy, ImportedEnergy, ExportedEnergy]>, Type<ElectricalEnergyMeasurement.Complete, Type<Of<{
    attributes: {
        accuracy: FixedAttribute<TypeFromFields<{
            accuracyRanges: ...;
            maxMeasuredValue: ...;
            measured: ...;
            measurementType: ...;
            minMeasuredValue: ...;
        }>, any>;
    };
    extensions: readonly [{
        component: {
            attributes: {
                cumulativeEnergyImported: ...;
            };
        };
        flags: {
            cumulativeEnergy: true;
            importedEnergy: true;
        };
    }, {
        component: {
            attributes: {
                cumulativeEnergyExported: ...;
            };
        };
        flags: {
            cumulativeEnergy: true;
            exportedEnergy: true;
        };
    }, {
        component: {
            attributes: {
                periodicEnergyImported: ...;
            };
        };
        flags: {
            importedEnergy: true;
            periodicEnergy: true;
        };
    }, {
        component: {
            attributes: {
                periodicEnergyExported: ...;
            };
        };
        flags: {
            exportedEnergy: true;
            periodicEnergy: true;
        };
    }, {
        component: {
            attributes: {
                cumulativeEnergyReset: ...;
            };
            events: {
                cumulativeEnergyMeasured: ...;
            };
        };
        flags: {
            cumulativeEnergy: true;
        };
    }, {
        component: {
            events: {
                periodicEnergyMeasured: ...;
            };
        };
        flags: {
            periodicEnergy: true;
        };
    }, {
        component: false;
        flags: {
            exportedEnergy: false;
            importedEnergy: false;
        };
    }, {
        component: false;
        flags: {
            cumulativeEnergy: false;
            periodicEnergy: false;
        };
    }];
    features: {
        cumulativeEnergy: BitFlag;
        exportedEnergy: BitFlag;
        importedEnergy: BitFlag;
        periodicEnergy: BitFlag;
    };
    id: 145;
    name: "ElectricalEnergyMeasurement";
    revision: 1;
}>, typeof ClusterBehavior, {
    components: never[];
}>, {
    components: never[];
}>>,
    | "accuracy"
    | "cumulativeEnergyImported"
    | "cumulativeEnergyExported"
    | "periodicEnergyImported"
    | "periodicEnergyExported"
    | "cumulativeEnergyReset"> & {} & {} & {
    accuracy: TypeFromFields<{
        accuracyRanges: FieldType<TypeFromFields<{
            fixedMax: OptionalFieldType<number | bigint>;
            fixedMin: OptionalFieldType<number | bigint>;
            fixedTypical: OptionalFieldType<number | bigint>;
            percentMax: OptionalFieldType<number>;
            percentMin: OptionalFieldType<number>;
            percentTypical: OptionalFieldType<number>;
            rangeMax: FieldType<number | bigint>;
            rangeMin: FieldType<number | bigint>;
        }>[]>;
        maxMeasuredValue: FieldType<number | bigint>;
        measured: FieldType<boolean>;
        measurementType: FieldType<MeasurementType>;
        minMeasuredValue: FieldType<number | bigint>;
    }>;
} & {}

Access the behavior's state.

Type declaration

Static Readonlycluster

cluster: Of<{
    attributes: {
        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>;
    };
    extensions: readonly [{
        component: {
            attributes: {
                cumulativeEnergyImported: Attribute<null | TypeFromFields<{
                    endSystime: OptionalFieldType<(...)>;
                    endTimestamp: OptionalFieldType<(...)>;
                    energy: FieldType<(...)>;
                    startSystime: OptionalFieldType<(...)>;
                    startTimestamp: OptionalFieldType<(...)>;
                }>, any>;
            };
        };
        flags: {
            cumulativeEnergy: true;
            importedEnergy: true;
        };
    }, {
        component: {
            attributes: {
                cumulativeEnergyExported: Attribute<null | TypeFromFields<{
                    endSystime: OptionalFieldType<(...)>;
                    endTimestamp: OptionalFieldType<(...)>;
                    energy: FieldType<(...)>;
                    startSystime: OptionalFieldType<(...)>;
                    startTimestamp: OptionalFieldType<(...)>;
                }>, any>;
            };
        };
        flags: {
            cumulativeEnergy: true;
            exportedEnergy: true;
        };
    }, {
        component: {
            attributes: {
                periodicEnergyImported: Attribute<null | TypeFromFields<{
                    endSystime: OptionalFieldType<(...)>;
                    endTimestamp: OptionalFieldType<(...)>;
                    energy: FieldType<(...)>;
                    startSystime: OptionalFieldType<(...)>;
                    startTimestamp: OptionalFieldType<(...)>;
                }>, any>;
            };
        };
        flags: {
            importedEnergy: true;
            periodicEnergy: true;
        };
    }, {
        component: {
            attributes: {
                periodicEnergyExported: Attribute<null | TypeFromFields<{
                    endSystime: OptionalFieldType<(...)>;
                    endTimestamp: OptionalFieldType<(...)>;
                    energy: FieldType<(...)>;
                    startSystime: OptionalFieldType<(...)>;
                    startTimestamp: OptionalFieldType<(...)>;
                }>, any>;
            };
        };
        flags: {
            exportedEnergy: true;
            periodicEnergy: true;
        };
    }, {
        component: {
            attributes: {
                cumulativeEnergyReset: OptionalAttribute<null | TypeFromFields<{
                    exportedResetSystime: OptionalFieldType<(...)>;
                    exportedResetTimestamp: OptionalFieldType<(...)>;
                    importedResetSystime: OptionalFieldType<(...)>;
                    importedResetTimestamp: OptionalFieldType<(...)>;
                }>, any>;
            };
            events: {
                cumulativeEnergyMeasured: Event<TypeFromFields<{
                    energyExported: OptionalFieldType<TypeFromFields<(...)>>;
                    energyImported: OptionalFieldType<TypeFromFields<(...)>>;
                }>, any>;
            };
        };
        flags: {
            cumulativeEnergy: true;
        };
    }, {
        component: {
            events: {
                periodicEnergyMeasured: Event<TypeFromFields<{
                    energyExported: OptionalFieldType<TypeFromFields<(...)>>;
                    energyImported: OptionalFieldType<TypeFromFields<(...)>>;
                }>, any>;
            };
        };
        flags: {
            periodicEnergy: true;
        };
    }, {
        component: false;
        flags: {
            exportedEnergy: false;
            importedEnergy: false;
        };
    }, {
        component: false;
        flags: {
            cumulativeEnergy: false;
            periodicEnergy: false;
        };
    }];
    features: {
        cumulativeEnergy: BitFlag;
        exportedEnergy: BitFlag;
        importedEnergy: BitFlag;
        periodicEnergy: BitFlag;
    };
    id: 145;
    name: "ElectricalEnergyMeasurement";
    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: 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>;
    }
  • Readonlyextensions: readonly [{
        component: {
            attributes: {
                cumulativeEnergyImported: Attribute<null | TypeFromFields<{
                    endSystime: OptionalFieldType<(...)>;
                    endTimestamp: OptionalFieldType<(...)>;
                    energy: FieldType<(...)>;
                    startSystime: OptionalFieldType<(...)>;
                    startTimestamp: OptionalFieldType<(...)>;
                }>, any>;
            };
        };
        flags: {
            cumulativeEnergy: true;
            importedEnergy: true;
        };
    }, {
        component: {
            attributes: {
                cumulativeEnergyExported: Attribute<null | TypeFromFields<{
                    endSystime: OptionalFieldType<(...)>;
                    endTimestamp: OptionalFieldType<(...)>;
                    energy: FieldType<(...)>;
                    startSystime: OptionalFieldType<(...)>;
                    startTimestamp: OptionalFieldType<(...)>;
                }>, any>;
            };
        };
        flags: {
            cumulativeEnergy: true;
            exportedEnergy: true;
        };
    }, {
        component: {
            attributes: {
                periodicEnergyImported: Attribute<null | TypeFromFields<{
                    endSystime: OptionalFieldType<(...)>;
                    endTimestamp: OptionalFieldType<(...)>;
                    energy: FieldType<(...)>;
                    startSystime: OptionalFieldType<(...)>;
                    startTimestamp: OptionalFieldType<(...)>;
                }>, any>;
            };
        };
        flags: {
            importedEnergy: true;
            periodicEnergy: true;
        };
    }, {
        component: {
            attributes: {
                periodicEnergyExported: Attribute<null | TypeFromFields<{
                    endSystime: OptionalFieldType<(...)>;
                    endTimestamp: OptionalFieldType<(...)>;
                    energy: FieldType<(...)>;
                    startSystime: OptionalFieldType<(...)>;
                    startTimestamp: OptionalFieldType<(...)>;
                }>, any>;
            };
        };
        flags: {
            exportedEnergy: true;
            periodicEnergy: true;
        };
    }, {
        component: {
            attributes: {
                cumulativeEnergyReset: OptionalAttribute<null | TypeFromFields<{
                    exportedResetSystime: OptionalFieldType<(...)>;
                    exportedResetTimestamp: OptionalFieldType<(...)>;
                    importedResetSystime: OptionalFieldType<(...)>;
                    importedResetTimestamp: OptionalFieldType<(...)>;
                }>, any>;
            };
            events: {
                cumulativeEnergyMeasured: Event<TypeFromFields<{
                    energyExported: OptionalFieldType<TypeFromFields<(...)>>;
                    energyImported: OptionalFieldType<TypeFromFields<(...)>>;
                }>, any>;
            };
        };
        flags: {
            cumulativeEnergy: true;
        };
    }, {
        component: {
            events: {
                periodicEnergyMeasured: Event<TypeFromFields<{
                    energyExported: OptionalFieldType<TypeFromFields<(...)>>;
                    energyImported: OptionalFieldType<TypeFromFields<(...)>>;
                }>, any>;
            };
        };
        flags: {
            periodicEnergy: true;
        };
    }, {
        component: false;
        flags: {
            exportedEnergy: false;
            importedEnergy: false;
        };
    }, {
        component: false;
        flags: {
            cumulativeEnergy: false;
            periodicEnergy: false;
        };
    }]

    This metadata controls which ElectricalEnergyMeasurementCluster elements matter.js activates for specific feature combinations.

  • Readonlyfeatures: {
        cumulativeEnergy: BitFlag;
        exportedEnergy: BitFlag;
        importedEnergy: BitFlag;
        periodicEnergy: BitFlag;
    }
    • ReadonlycumulativeEnergy: BitFlag

      CumulativeEnergy

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

      See

      MatterSpecification.v13.Cluster § 2.12.4.3

    • ReadonlyexportedEnergy: BitFlag

      ExportedEnergy

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

      See

      MatterSpecification.v13.Cluster § 2.12.4.2

    • ReadonlyimportedEnergy: BitFlag

      ImportedEnergy

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

      See

      MatterSpecification.v13.Cluster § 2.12.4.1

    • ReadonlyperiodicEnergy: BitFlag

      PeriodicEnergy

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

      See

      MatterSpecification.v13.Cluster § 2.12.4.4

  • Readonlyid: 145
  • Readonlyname: "ElectricalEnergyMeasurement"
  • Readonlyrevision: 1

Static Readonlydefaults

defaults: ClusterState.Type<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>;
    };
    extensions: readonly [{
        component: {
            attributes: {
                cumulativeEnergyImported: Attribute<null | TypeFromFields<{
                    endSystime: ...;
                    endTimestamp: ...;
                    energy: ...;
                    startSystime: ...;
                    startTimestamp: ...;
                }>, any>;
            };
        };
        flags: {
            cumulativeEnergy: true;
            importedEnergy: true;
        };
    }, {
        component: {
            attributes: {
                cumulativeEnergyExported: Attribute<null | TypeFromFields<{
                    endSystime: ...;
                    endTimestamp: ...;
                    energy: ...;
                    startSystime: ...;
                    startTimestamp: ...;
                }>, any>;
            };
        };
        flags: {
            cumulativeEnergy: true;
            exportedEnergy: true;
        };
    }, {
        component: {
            attributes: {
                periodicEnergyImported: Attribute<null | TypeFromFields<{
                    endSystime: ...;
                    endTimestamp: ...;
                    energy: ...;
                    startSystime: ...;
                    startTimestamp: ...;
                }>, any>;
            };
        };
        flags: {
            importedEnergy: true;
            periodicEnergy: true;
        };
    }, {
        component: {
            attributes: {
                periodicEnergyExported: Attribute<null | TypeFromFields<{
                    endSystime: ...;
                    endTimestamp: ...;
                    energy: ...;
                    startSystime: ...;
                    startTimestamp: ...;
                }>, any>;
            };
        };
        flags: {
            exportedEnergy: true;
            periodicEnergy: true;
        };
    }, {
        component: {
            attributes: {
                cumulativeEnergyReset: OptionalAttribute<null | TypeFromFields<{
                    exportedResetSystime: ...;
                    exportedResetTimestamp: ...;
                    importedResetSystime: ...;
                    importedResetTimestamp: ...;
                }>, any>;
            };
            events: {
                cumulativeEnergyMeasured: Event<TypeFromFields<{
                    energyExported: OptionalFieldType<(...)>;
                    energyImported: OptionalFieldType<(...)>;
                }>, any>;
            };
        };
        flags: {
            cumulativeEnergy: true;
        };
    }, {
        component: {
            events: {
                periodicEnergyMeasured: Event<TypeFromFields<{
                    energyExported: OptionalFieldType<(...)>;
                    energyImported: OptionalFieldType<(...)>;
                }>, any>;
            };
        };
        flags: {
            periodicEnergy: true;
        };
    }, {
        component: false;
        flags: {
            exportedEnergy: false;
            importedEnergy: false;
        };
    }, {
        component: false;
        flags: {
            cumulativeEnergy: false;
            periodicEnergy: false;
        };
    }];
    features: {
        cumulativeEnergy: BitFlag;
        exportedEnergy: BitFlag;
        importedEnergy: BitFlag;
        periodicEnergy: BitFlag;
    };
    id: 145;
    name: "ElectricalEnergyMeasurement";
    revision: 1;
}>, typeof ElectricalEnergyMeasurementServerLogic>

Static Optional Readonlydependencies

dependencies?: Iterable<Type, any, any>

Static Readonlyearly

early: boolean

Static ReadonlyEvents

Events: ClusterEvents.Type<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>;
    };
    extensions: readonly [{
        component: {
            attributes: {
                cumulativeEnergyImported: Attribute<null | TypeFromFields<{
                    endSystime: ...;
                    endTimestamp: ...;
                    energy: ...;
                    startSystime: ...;
                    startTimestamp: ...;
                }>, any>;
            };
        };
        flags: {
            cumulativeEnergy: true;
            importedEnergy: true;
        };
    }, {
        component: {
            attributes: {
                cumulativeEnergyExported: Attribute<null | TypeFromFields<{
                    endSystime: ...;
                    endTimestamp: ...;
                    energy: ...;
                    startSystime: ...;
                    startTimestamp: ...;
                }>, any>;
            };
        };
        flags: {
            cumulativeEnergy: true;
            exportedEnergy: true;
        };
    }, {
        component: {
            attributes: {
                periodicEnergyImported: Attribute<null | TypeFromFields<{
                    endSystime: ...;
                    endTimestamp: ...;
                    energy: ...;
                    startSystime: ...;
                    startTimestamp: ...;
                }>, any>;
            };
        };
        flags: {
            importedEnergy: true;
            periodicEnergy: true;
        };
    }, {
        component: {
            attributes: {
                periodicEnergyExported: Attribute<null | TypeFromFields<{
                    endSystime: ...;
                    endTimestamp: ...;
                    energy: ...;
                    startSystime: ...;
                    startTimestamp: ...;
                }>, any>;
            };
        };
        flags: {
            exportedEnergy: true;
            periodicEnergy: true;
        };
    }, {
        component: {
            attributes: {
                cumulativeEnergyReset: OptionalAttribute<null | TypeFromFields<{
                    exportedResetSystime: ...;
                    exportedResetTimestamp: ...;
                    importedResetSystime: ...;
                    importedResetTimestamp: ...;
                }>, any>;
            };
            events: {
                cumulativeEnergyMeasured: Event<TypeFromFields<{
                    energyExported: OptionalFieldType<(...)>;
                    energyImported: OptionalFieldType<(...)>;
                }>, any>;
            };
        };
        flags: {
            cumulativeEnergy: true;
        };
    }, {
        component: {
            events: {
                periodicEnergyMeasured: Event<TypeFromFields<{
                    energyExported: OptionalFieldType<(...)>;
                    energyImported: OptionalFieldType<(...)>;
                }>, any>;
            };
        };
        flags: {
            periodicEnergy: true;
        };
    }, {
        component: false;
        flags: {
            exportedEnergy: false;
            importedEnergy: false;
        };
    }, {
        component: false;
        flags: {
            cumulativeEnergy: false;
            periodicEnergy: false;
        };
    }];
    features: {
        cumulativeEnergy: BitFlag;
        exportedEnergy: BitFlag;
        importedEnergy: BitFlag;
        periodicEnergy: BitFlag;
    };
    id: 145;
    name: "ElectricalEnergyMeasurement";
    revision: 1;
}>, typeof ElectricalEnergyMeasurementServerLogic>

Static ReadonlyExtensionInterface

ExtensionInterface: {
    setMeasurement(measurement: AtomicElectricalEnergyMeasurement): void;
}

Static Readonlyid

id

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

Static ReadonlyInterface

Interface: {
    components: never[];
}

Static ReadonlyInternal

Internal: (new () => {})

Static Readonlyname

name: string

Static Optional Readonlyschema

schema?: Schema

Static ReadonlyState

State: (new () => 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>;
    };
    extensions: readonly [{
        component: {
            attributes: {
                cumulativeEnergyImported: Attribute<null | TypeFromFields<(...)>, any>;
            };
        };
        flags: {
            cumulativeEnergy: true;
            importedEnergy: true;
        };
    }, {
        component: {
            attributes: {
                cumulativeEnergyExported: Attribute<null | TypeFromFields<(...)>, any>;
            };
        };
        flags: {
            cumulativeEnergy: true;
            exportedEnergy: true;
        };
    }, {
        component: {
            attributes: {
                periodicEnergyImported: Attribute<null | TypeFromFields<(...)>, any>;
            };
        };
        flags: {
            importedEnergy: true;
            periodicEnergy: true;
        };
    }, {
        component: {
            attributes: {
                periodicEnergyExported: Attribute<null | TypeFromFields<(...)>, any>;
            };
        };
        flags: {
            exportedEnergy: true;
            periodicEnergy: true;
        };
    }, {
        component: {
            attributes: {
                cumulativeEnergyReset: OptionalAttribute<null | TypeFromFields<(...)>, any>;
            };
            events: {
                cumulativeEnergyMeasured: Event<TypeFromFields<{
                    energyExported: ...;
                    energyImported: ...;
                }>, any>;
            };
        };
        flags: {
            cumulativeEnergy: true;
        };
    }, {
        component: {
            events: {
                periodicEnergyMeasured: Event<TypeFromFields<{
                    energyExported: ...;
                    energyImported: ...;
                }>, any>;
            };
        };
        flags: {
            periodicEnergy: true;
        };
    }, {
        component: false;
        flags: {
            exportedEnergy: false;
            importedEnergy: false;
        };
    }, {
        component: false;
        flags: {
            cumulativeEnergy: false;
            periodicEnergy: false;
        };
    }];
    features: {
        cumulativeEnergy: BitFlag;
        exportedEnergy: BitFlag;
        importedEnergy: BitFlag;
        periodicEnergy: BitFlag;
    };
    id: 145;
    name: "ElectricalEnergyMeasurement";
    revision: 1;
}>, typeof ElectricalEnergyMeasurementServerLogic>)

Static Readonlysupervisor

supervisor: RootSupervisor

Staticsupports

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

Type declaration

    • (other): boolean

    • Does this behavior support functionality of a specific implementation?

      Parameters

      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

asAdmin

  • asAdmin(fn): void

  • Parameters

    • fn: (() => void)

      the elevated logic

        • (): void

        • Returns void

    Returns void

assertAttributeEnabled

Protectedcallback

  • 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

    Returns ((...args: A) => undefined | R)

      • (...args): undefined | R

      • Parameters

        • Rest...args: A

        Returns undefined | R

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

    ProtectedreactTo

    • 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

      Parameters

      Returns void

    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>

    setMeasurement

    toString

    Staticalter

    Staticenable

    Staticfor

    Staticset

    Staticwith

    Settings

    Member Visibility

    On This Page

    Constructors
    Properties
    Methods