Interface Cluster

This cluster provides an interface for observing and managing the state of smoke and CO alarms.

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

See

MatterSpecification.v13.Cluster § 2.11

interface Cluster {
    id: ClusterId;
    name: string;
    with: (<const SelectionT>(...selection: SelectionT) => Of<Of<{
        attributes: {
            batteryAlert: Attribute<SmokeCoAlarm.AlarmState, any>;
            deviceMuted: OptionalAttribute<SmokeCoAlarm.MuteState, any>;
            endOfServiceAlert: Attribute<SmokeCoAlarm.EndOfService, any>;
            expiryDate: OptionalFixedAttribute<number, any>;
            expressedState: Attribute<SmokeCoAlarm.ExpressedState, any>;
            hardwareFaultAlert: Attribute<boolean, any>;
            interconnectCoAlarm: OptionalAttribute<SmokeCoAlarm.AlarmState, any>;
            interconnectSmokeAlarm: OptionalAttribute<SmokeCoAlarm.AlarmState, any>;
            testInProgress: Attribute<boolean, any>;
        };
        commands: {
            selfTestRequest: OptionalCommand<void, void, any>;
        };
        events: {
            alarmMuted: OptionalEvent<void, any>;
            allClear: Event<void, any>;
            endOfService: Event<void, any>;
            hardwareFault: Event<void, any>;
            lowBattery: Event<TypeFromFields<{
                alarmSeverityLevel: FieldType<SmokeCoAlarm.AlarmState>;
            }>, any>;
            muteEnded: OptionalEvent<void, any>;
            selfTestComplete: Event<void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    contaminationState: OptionalAttribute<SmokeCoAlarm.ContaminationState, any>;
                    smokeSensitivityLevel: OptionalWritableAttribute<SmokeCoAlarm.Sensitivity, any>;
                    smokeState: Attribute<SmokeCoAlarm.AlarmState, any>;
                };
                events: {
                    interconnectSmokeAlarm: OptionalEvent<TypeFromFields<{
                        alarmSeverityLevel: ...;
                    }>, any>;
                    smokeAlarm: Event<TypeFromFields<{
                        alarmSeverityLevel: ...;
                    }>, any>;
                };
            };
            flags: {
                smokeAlarm: true;
            };
        }, {
            component: {
                attributes: {
                    coState: Attribute<SmokeCoAlarm.AlarmState, any>;
                };
                events: {
                    coAlarm: Event<TypeFromFields<{
                        alarmSeverityLevel: ...;
                    }>, any>;
                    interconnectCoAlarm: OptionalEvent<TypeFromFields<{
                        alarmSeverityLevel: ...;
                    }>, any>;
                };
            };
            flags: {
                coAlarm: true;
            };
        }, {
            component: false;
            flags: {
                coAlarm: false;
                smokeAlarm: false;
            };
        }];
        features: {
            coAlarm: BitFlag;
            smokeAlarm: BitFlag;
        };
        id: 92;
        name: "SmokeCoAlarm";
        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: {
        batteryAlert: Attribute<SmokeCoAlarm.AlarmState, any>;
        deviceMuted: OptionalAttribute<SmokeCoAlarm.MuteState, any>;
        endOfServiceAlert: Attribute<SmokeCoAlarm.EndOfService, any>;
        expiryDate: OptionalFixedAttribute<number, any>;
        expressedState: Attribute<SmokeCoAlarm.ExpressedState, any>;
        hardwareFaultAlert: Attribute<boolean, any>;
        interconnectCoAlarm: OptionalAttribute<SmokeCoAlarm.AlarmState, any>;
        interconnectSmokeAlarm: OptionalAttribute<SmokeCoAlarm.AlarmState, any>;
        testInProgress: Attribute<boolean, any>;
    };
    commands: {
        selfTestRequest: OptionalCommand<void, void, any>;
    };
    events: {
        alarmMuted: OptionalEvent<void, any>;
        allClear: Event<void, any>;
        endOfService: Event<void, any>;
        hardwareFault: Event<void, any>;
        lowBattery: Event<TypeFromFields<{
            alarmSeverityLevel: FieldType<SmokeCoAlarm.AlarmState>;
        }>, any>;
        muteEnded: OptionalEvent<void, any>;
        selfTestComplete: Event<void, any>;
    };
    extensions: readonly [{
        component: {
            attributes: {
                contaminationState: OptionalAttribute<SmokeCoAlarm.ContaminationState, any>;
                smokeSensitivityLevel: OptionalWritableAttribute<SmokeCoAlarm.Sensitivity, any>;
                smokeState: Attribute<SmokeCoAlarm.AlarmState, any>;
            };
            events: {
                interconnectSmokeAlarm: OptionalEvent<TypeFromFields<{
                    alarmSeverityLevel: ...;
                }>, any>;
                smokeAlarm: Event<TypeFromFields<{
                    alarmSeverityLevel: ...;
                }>, any>;
            };
        };
        flags: {
            smokeAlarm: true;
        };
    }, {
        component: {
            attributes: {
                coState: Attribute<SmokeCoAlarm.AlarmState, any>;
            };
            events: {
                coAlarm: Event<TypeFromFields<{
                    alarmSeverityLevel: ...;
                }>, any>;
                interconnectCoAlarm: OptionalEvent<TypeFromFields<{
                    alarmSeverityLevel: ...;
                }>, any>;
            };
        };
        flags: {
            coAlarm: true;
        };
    }, {
        component: false;
        flags: {
            coAlarm: false;
            smokeAlarm: false;
        };
    }];
    features: {
        coAlarm: BitFlag;
        smokeAlarm: BitFlag;
    };
    id: 92;
    name: "SmokeCoAlarm";
    revision: 1;
}>, SelectionT>)

Type declaration

    • <const SelectionT>(...selection): Of<Of<{
          attributes: {
              batteryAlert: Attribute<SmokeCoAlarm.AlarmState, any>;
              deviceMuted: OptionalAttribute<SmokeCoAlarm.MuteState, any>;
              endOfServiceAlert: Attribute<SmokeCoAlarm.EndOfService, any>;
              expiryDate: OptionalFixedAttribute<number, any>;
              expressedState: Attribute<SmokeCoAlarm.ExpressedState, any>;
              hardwareFaultAlert: Attribute<boolean, any>;
              interconnectCoAlarm: OptionalAttribute<SmokeCoAlarm.AlarmState, any>;
              interconnectSmokeAlarm: OptionalAttribute<SmokeCoAlarm.AlarmState, any>;
              testInProgress: Attribute<boolean, any>;
          };
          commands: {
              selfTestRequest: OptionalCommand<void, void, any>;
          };
          events: {
              alarmMuted: OptionalEvent<void, any>;
              allClear: Event<void, any>;
              endOfService: Event<void, any>;
              hardwareFault: Event<void, any>;
              lowBattery: Event<TypeFromFields<{
                  alarmSeverityLevel: FieldType<SmokeCoAlarm.AlarmState>;
              }>, any>;
              muteEnded: OptionalEvent<void, any>;
              selfTestComplete: Event<void, any>;
          };
          extensions: readonly [{
              component: {
                  attributes: {
                      contaminationState: OptionalAttribute<SmokeCoAlarm.ContaminationState, any>;
                      smokeSensitivityLevel: OptionalWritableAttribute<SmokeCoAlarm.Sensitivity, any>;
                      smokeState: Attribute<SmokeCoAlarm.AlarmState, any>;
                  };
                  events: {
                      interconnectSmokeAlarm: OptionalEvent<TypeFromFields<{
                          alarmSeverityLevel: ...;
                      }>, any>;
                      smokeAlarm: Event<TypeFromFields<{
                          alarmSeverityLevel: ...;
                      }>, any>;
                  };
              };
              flags: {
                  smokeAlarm: true;
              };
          }, {
              component: {
                  attributes: {
                      coState: Attribute<SmokeCoAlarm.AlarmState, any>;
                  };
                  events: {
                      coAlarm: Event<TypeFromFields<{
                          alarmSeverityLevel: ...;
                      }>, any>;
                      interconnectCoAlarm: OptionalEvent<TypeFromFields<{
                          alarmSeverityLevel: ...;
                      }>, any>;
                  };
              };
              flags: {
                  coAlarm: true;
              };
          }, {
              component: false;
              flags: {
                  coAlarm: false;
                  smokeAlarm: false;
              };
          }];
          features: {
              coAlarm: BitFlag;
              smokeAlarm: BitFlag;
          };
          id: 92;
          name: "SmokeCoAlarm";
          revision: 1;
      }>, SelectionT>

    • Select features using ClusterComposer.compose.

      Type Parameters

      • const SelectionT extends FeatureSelection<Of<{
            attributes: {
                batteryAlert: Attribute<SmokeCoAlarm.AlarmState, any>;
                deviceMuted: OptionalAttribute<SmokeCoAlarm.MuteState, any>;
                endOfServiceAlert: Attribute<SmokeCoAlarm.EndOfService, any>;
                expiryDate: OptionalFixedAttribute<number, any>;
                expressedState: Attribute<SmokeCoAlarm.ExpressedState, any>;
                hardwareFaultAlert: Attribute<boolean, any>;
                interconnectCoAlarm: OptionalAttribute<SmokeCoAlarm.AlarmState, any>;
                interconnectSmokeAlarm: OptionalAttribute<SmokeCoAlarm.AlarmState, any>;
                testInProgress: Attribute<boolean, any>;
            };
            commands: {
                selfTestRequest: OptionalCommand<void, void, any>;
            };
            events: {
                alarmMuted: OptionalEvent<void, any>;
                allClear: Event<void, any>;
                endOfService: Event<void, any>;
                hardwareFault: Event<void, any>;
                lowBattery: Event<TypeFromFields<{
                    alarmSeverityLevel: FieldType<SmokeCoAlarm.AlarmState>;
                }>, any>;
                muteEnded: OptionalEvent<void, any>;
                selfTestComplete: Event<void, any>;
            };
            extensions: readonly [{
                component: {
                    attributes: {
                        contaminationState: OptionalAttribute<SmokeCoAlarm.ContaminationState, any>;
                        smokeSensitivityLevel: OptionalWritableAttribute<SmokeCoAlarm.Sensitivity, any>;
                        smokeState: Attribute<SmokeCoAlarm.AlarmState, any>;
                    };
                    events: {
                        interconnectSmokeAlarm: OptionalEvent<TypeFromFields<{
                            alarmSeverityLevel: ...;
                        }>, any>;
                        smokeAlarm: Event<TypeFromFields<{
                            alarmSeverityLevel: ...;
                        }>, any>;
                    };
                };
                flags: {
                    smokeAlarm: true;
                };
            }, {
                component: {
                    attributes: {
                        coState: Attribute<SmokeCoAlarm.AlarmState, any>;
                    };
                    events: {
                        coAlarm: Event<TypeFromFields<{
                            alarmSeverityLevel: ...;
                        }>, any>;
                        interconnectCoAlarm: OptionalEvent<TypeFromFields<{
                            alarmSeverityLevel: ...;
                        }>, any>;
                    };
                };
                flags: {
                    coAlarm: true;
                };
            }, {
                component: false;
                flags: {
                    coAlarm: false;
                    smokeAlarm: false;
                };
            }];
            features: {
                coAlarm: BitFlag;
                smokeAlarm: BitFlag;
            };
            id: 92;
            name: "SmokeCoAlarm";
            revision: 1;
        }>>

      Parameters

      Returns Of<Of<{
          attributes: {
              batteryAlert: Attribute<SmokeCoAlarm.AlarmState, any>;
              deviceMuted: OptionalAttribute<SmokeCoAlarm.MuteState, any>;
              endOfServiceAlert: Attribute<SmokeCoAlarm.EndOfService, any>;
              expiryDate: OptionalFixedAttribute<number, any>;
              expressedState: Attribute<SmokeCoAlarm.ExpressedState, any>;
              hardwareFaultAlert: Attribute<boolean, any>;
              interconnectCoAlarm: OptionalAttribute<SmokeCoAlarm.AlarmState, any>;
              interconnectSmokeAlarm: OptionalAttribute<SmokeCoAlarm.AlarmState, any>;
              testInProgress: Attribute<boolean, any>;
          };
          commands: {
              selfTestRequest: OptionalCommand<void, void, any>;
          };
          events: {
              alarmMuted: OptionalEvent<void, any>;
              allClear: Event<void, any>;
              endOfService: Event<void, any>;
              hardwareFault: Event<void, any>;
              lowBattery: Event<TypeFromFields<{
                  alarmSeverityLevel: FieldType<SmokeCoAlarm.AlarmState>;
              }>, any>;
              muteEnded: OptionalEvent<void, any>;
              selfTestComplete: Event<void, any>;
          };
          extensions: readonly [{
              component: {
                  attributes: {
                      contaminationState: OptionalAttribute<SmokeCoAlarm.ContaminationState, any>;
                      smokeSensitivityLevel: OptionalWritableAttribute<SmokeCoAlarm.Sensitivity, any>;
                      smokeState: Attribute<SmokeCoAlarm.AlarmState, any>;
                  };
                  events: {
                      interconnectSmokeAlarm: OptionalEvent<TypeFromFields<{
                          alarmSeverityLevel: ...;
                      }>, any>;
                      smokeAlarm: Event<TypeFromFields<{
                          alarmSeverityLevel: ...;
                      }>, any>;
                  };
              };
              flags: {
                  smokeAlarm: true;
              };
          }, {
              component: {
                  attributes: {
                      coState: Attribute<SmokeCoAlarm.AlarmState, any>;
                  };
                  events: {
                      coAlarm: Event<TypeFromFields<{
                          alarmSeverityLevel: ...;
                      }>, any>;
                      interconnectCoAlarm: OptionalEvent<TypeFromFields<{
                          alarmSeverityLevel: ...;
                      }>, any>;
                  };
              };
              flags: {
                  coAlarm: true;
              };
          }, {
              component: false;
              flags: {
                  coAlarm: false;
                  smokeAlarm: false;
              };
          }];
          features: {
              coAlarm: BitFlag;
              smokeAlarm: BitFlag;
          };
          id: 92;
          name: "SmokeCoAlarm";
          revision: 1;
      }>, SelectionT>

Settings

Member Visibility

On This Page

Properties