Interface Cluster

This cluster provides a mechanism for querying data about the electrical energy imported or provided by the server.

Per the Matter specification you cannot use ElectricalEnergyMeasurementCluster without enabling certain feature combinations. You must use the with factory method to obtain a working cluster.

See

MatterSpecification.v13.Cluster § 2.12

interface Cluster {
    id: ClusterId;
    name: string;
    with: (<const SelectionT>(...selection: SelectionT) => Of<Of<{
        attributes: {
            accuracy: FixedAttribute<TypeFromFields<{
                accuracyRanges: FieldType<TypeFromFields<(...)>[]>;
                maxMeasuredValue: FieldType<number | bigint>;
                measured: FieldType<boolean>;
                measurementType: FieldType<MeasurementType>;
                minMeasuredValue: FieldType<number | bigint>;
            }>, any>;
        };
        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;
    }>, SelectionT>);
}

Hierarchy (view full)

Properties

id name with

Properties

id

id: ClusterId

name

name: string

with

with: (<const SelectionT>(...selection: SelectionT) => Of<Of<{
    attributes: {
        accuracy: FixedAttribute<TypeFromFields<{
            accuracyRanges: FieldType<TypeFromFields<(...)>[]>;
            maxMeasuredValue: FieldType<number | bigint>;
            measured: FieldType<boolean>;
            measurementType: FieldType<MeasurementType>;
            minMeasuredValue: FieldType<number | bigint>;
        }>, any>;
    };
    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;
}>, SelectionT>)

Type declaration

    • <const SelectionT>(...selection): Of<Of<{
          attributes: {
              accuracy: FixedAttribute<TypeFromFields<{
                  accuracyRanges: FieldType<TypeFromFields<(...)>[]>;
                  maxMeasuredValue: FieldType<number | bigint>;
                  measured: FieldType<boolean>;
                  measurementType: FieldType<MeasurementType>;
                  minMeasuredValue: FieldType<number | bigint>;
              }>, any>;
          };
          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;
      }>, SelectionT>

    • Select features using ClusterComposer.compose.

      Type Parameters

      • const SelectionT extends FeatureSelection<Of<{
            attributes: {
                accuracy: FixedAttribute<TypeFromFields<{
                    accuracyRanges: FieldType<TypeFromFields<(...)>[]>;
                    maxMeasuredValue: FieldType<number | bigint>;
                    measured: FieldType<boolean>;
                    measurementType: FieldType<MeasurementType>;
                    minMeasuredValue: FieldType<number | bigint>;
                }>, any>;
            };
            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;
        }>>

      Parameters

      Returns Of<Of<{
          attributes: {
              accuracy: FixedAttribute<TypeFromFields<{
                  accuracyRanges: FieldType<TypeFromFields<(...)>[]>;
                  maxMeasuredValue: FieldType<number | bigint>;
                  measured: FieldType<boolean>;
                  measurementType: FieldType<MeasurementType>;
                  minMeasuredValue: FieldType<number | bigint>;
              }>, any>;
          };
          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;
      }>, SelectionT>

Settings

Member Visibility

On This Page

Properties