Interface Cluster

This cluster is a derived cluster of Alarm Base cluster.

RefrigeratorAlarmCluster supports optional features that you can enable with the RefrigeratorAlarmCluster.with() factory method.

See

MatterSpecification.v13.Cluster § 8.8

interface Cluster {
    attributes: Merge<{
        mask: Attribute<number, any>;
        state: Attribute<number, any>;
        supported: FixedAttribute<number, any>;
    }, GlobalAttributes<{
        reset: BitFlag;
    }>>;
    base: undefined;
    commands: {};
    events: {
        notify: Event<TypeFromFields<{
            active: FieldType<number>;
            inactive: FieldType<number>;
            mask: FieldType<number>;
            state: FieldType<number>;
        }>, any>;
    };
    extensions: readonly [{
        component: {
            attributes: {
                latch: FixedAttribute<number, any>;
            };
            commands: {
                reset: Command<TypeFromFields<{
                    alarms: FieldType<number>;
                }>, void, any>;
            };
        };
        flags: {
            reset: true;
        };
    }, {
        component: false;
        flags: {
            reset: true;
        };
    }];
    features: {
        reset: BitFlag;
    };
    id: Branded<87, "ClusterId">;
    name: "RefrigeratorAlarm";
    revision: 1;
    supportedFeatures: {};
    unknown: false;
    alter<const AlterationsT>(alterations: AlterationsT): WithAlterations<Of<{
        attributes: {
            mask: Attribute<number, any>;
            state: Attribute<number, any>;
            supported: FixedAttribute<number, any>;
        };
        events: {
            notify: Event<TypeFromFields<{
                active: FieldType<number>;
                inactive: FieldType<number>;
                mask: FieldType<number>;
                state: FieldType<number>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    latch: FixedAttribute<number, any>;
                };
                commands: {
                    reset: Command<TypeFromFields<{
                        alarms: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                reset: true;
            };
        }, {
            component: false;
            flags: {
                reset: true;
            };
        }];
        features: {
            reset: BitFlag;
        };
        id: 87;
        name: "RefrigeratorAlarm";
        revision: 1;
    }>, AlterationsT>;
    enable<const FlagsT>(flags: FlagsT): WithFlags<Of<{
        attributes: {
            mask: Attribute<number, any>;
            state: Attribute<number, any>;
            supported: FixedAttribute<number, any>;
        };
        events: {
            notify: Event<TypeFromFields<{
                active: FieldType<number>;
                inactive: FieldType<number>;
                mask: FieldType<number>;
                state: FieldType<number>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    latch: FixedAttribute<number, any>;
                };
                commands: {
                    reset: Command<TypeFromFields<{
                        alarms: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                reset: true;
            };
        }, {
            component: false;
            flags: {
                reset: true;
            };
        }];
        features: {
            reset: BitFlag;
        };
        id: 87;
        name: "RefrigeratorAlarm";
        revision: 1;
    }>, FlagsT>;
    set<const ValuesT>(values: ValuesT): WithValues<Of<{
        attributes: {
            mask: Attribute<number, any>;
            state: Attribute<number, any>;
            supported: FixedAttribute<number, any>;
        };
        events: {
            notify: Event<TypeFromFields<{
                active: FieldType<number>;
                inactive: FieldType<number>;
                mask: FieldType<number>;
                state: FieldType<number>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    latch: FixedAttribute<number, any>;
                };
                commands: {
                    reset: Command<TypeFromFields<{
                        alarms: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                reset: true;
            };
        }, {
            component: false;
            flags: {
                reset: true;
            };
        }];
        features: {
            reset: BitFlag;
        };
        id: 87;
        name: "RefrigeratorAlarm";
        revision: 1;
    }>, ValuesT>;
    with<const SelectionT>(...selection: SelectionT): Of<Of<{
        attributes: {
            mask: Attribute<number, any>;
            state: Attribute<number, any>;
            supported: FixedAttribute<number, any>;
        };
        events: {
            notify: Event<TypeFromFields<{
                active: FieldType<number>;
                inactive: FieldType<number>;
                mask: FieldType<number>;
                state: FieldType<number>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    latch: FixedAttribute<number, any>;
                };
                commands: {
                    reset: Command<TypeFromFields<{
                        alarms: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                reset: true;
            };
        }, {
            component: false;
            flags: {
                reset: true;
            };
        }];
        features: {
            reset: BitFlag;
        };
        id: 87;
        name: "RefrigeratorAlarm";
        revision: 1;
    }>, SelectionT>;
}

Hierarchy (view full)

Properties

attributes base commands events extensions features id name revision supportedFeatures unknown

Methods

alter enable set with

Properties

attributes

attributes: Merge<{
    mask: Attribute<number, any>;
    state: Attribute<number, any>;
    supported: FixedAttribute<number, any>;
}, GlobalAttributes<{
    reset: BitFlag;
}>>

Type declaration

  • Readonlymask: Attribute<number, any>

    Indicates a bitmap where each bit set in the Mask attribute corresponds to an alarm that shall be enabled.

    See

    MatterSpecification.v13.Cluster § 1.15.6.1

  • Readonlystate: Attribute<number, any>

    Indicates a bitmap where each bit shall represent the state of an alarm. The value of true means the alarm is active, otherwise the alarm is inactive.

    See

    MatterSpecification.v13.Cluster § 1.15.6.3

  • Readonlysupported: FixedAttribute<number, any>

    Indicates a bitmap where each bit shall represent whether or not an alarm is supported. The value of true means the alarm is supported, otherwise the alarm is not supported.

    If an alarm is not supported, the corresponding bit in Mask, Latch, and State shall be false.

    See

    MatterSpecification.v13.Cluster § 1.15.6.4

base

base: undefined

commands

commands: {}

events

events: {
    notify: Event<TypeFromFields<{
        active: FieldType<number>;
        inactive: FieldType<number>;
        mask: FieldType<number>;
        state: FieldType<number>;
    }>, any>;
}

Type declaration

  • Readonlynotify: Event<TypeFromFields<{
        active: FieldType<number>;
        inactive: FieldType<number>;
        mask: FieldType<number>;
        state: FieldType<number>;
    }>, any>

    This event shall be generated when one or more alarms change state, and shall have these fields:

    See

    MatterSpecification.v13.Cluster § 1.15.8.1

extensions

extensions: readonly [{
    component: {
        attributes: {
            latch: FixedAttribute<number, any>;
        };
        commands: {
            reset: Command<TypeFromFields<{
                alarms: FieldType<number>;
            }>, void, any>;
        };
    };
    flags: {
        reset: true;
    };
}, {
    component: false;
    flags: {
        reset: true;
    };
}]

features

features: {
    reset: BitFlag;
}

Type declaration

  • Readonlyreset: BitFlag

    Reset

    Supports the ability to reset alarms

id

id: Branded<87, "ClusterId">

name

name

revision

revision

supportedFeatures

supportedFeatures: {}

unknown

unknown

Methods

alter

  • alter<const AlterationsT>(alterations): WithAlterations<Of<{
        attributes: {
            mask: Attribute<number, any>;
            state: Attribute<number, any>;
            supported: FixedAttribute<number, any>;
        };
        events: {
            notify: Event<TypeFromFields<{
                active: FieldType<number>;
                inactive: FieldType<number>;
                mask: FieldType<number>;
                state: FieldType<number>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    latch: FixedAttribute<number, any>;
                };
                commands: {
                    reset: Command<TypeFromFields<{
                        alarms: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                reset: true;
            };
        }, {
            component: false;
            flags: {
                reset: true;
            };
        }];
        features: {
            reset: BitFlag;
        };
        id: 87;
        name: "RefrigeratorAlarm";
        revision: 1;
    }>, AlterationsT>

  • Modify elements using ElementModifier.alter.

    Type Parameters

    • const AlterationsT extends Alterations<Of<{
          attributes: {
              mask: Attribute<number, any>;
              state: Attribute<number, any>;
              supported: FixedAttribute<number, any>;
          };
          events: {
              notify: Event<TypeFromFields<{
                  active: FieldType<number>;
                  inactive: FieldType<number>;
                  mask: FieldType<number>;
                  state: FieldType<number>;
              }>, any>;
          };
          extensions: readonly [{
              component: {
                  attributes: {
                      latch: FixedAttribute<number, any>;
                  };
                  commands: {
                      reset: Command<TypeFromFields<{
                          alarms: FieldType<(...)>;
                      }>, void, any>;
                  };
              };
              flags: {
                  reset: true;
              };
          }, {
              component: false;
              flags: {
                  reset: true;
              };
          }];
          features: {
              reset: BitFlag;
          };
          id: 87;
          name: "RefrigeratorAlarm";
          revision: 1;
      }>>

    Parameters

    Returns WithAlterations<Of<{
        attributes: {
            mask: Attribute<number, any>;
            state: Attribute<number, any>;
            supported: FixedAttribute<number, any>;
        };
        events: {
            notify: Event<TypeFromFields<{
                active: FieldType<number>;
                inactive: FieldType<number>;
                mask: FieldType<number>;
                state: FieldType<number>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    latch: FixedAttribute<number, any>;
                };
                commands: {
                    reset: Command<TypeFromFields<{
                        alarms: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                reset: true;
            };
        }, {
            component: false;
            flags: {
                reset: true;
            };
        }];
        features: {
            reset: BitFlag;
        };
        id: 87;
        name: "RefrigeratorAlarm";
        revision: 1;
    }>, AlterationsT>

enable

  • enable<const FlagsT>(flags): WithFlags<Of<{
        attributes: {
            mask: Attribute<number, any>;
            state: Attribute<number, any>;
            supported: FixedAttribute<number, any>;
        };
        events: {
            notify: Event<TypeFromFields<{
                active: FieldType<number>;
                inactive: FieldType<number>;
                mask: FieldType<number>;
                state: FieldType<number>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    latch: FixedAttribute<number, any>;
                };
                commands: {
                    reset: Command<TypeFromFields<{
                        alarms: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                reset: true;
            };
        }, {
            component: false;
            flags: {
                reset: true;
            };
        }];
        features: {
            reset: BitFlag;
        };
        id: 87;
        name: "RefrigeratorAlarm";
        revision: 1;
    }>, FlagsT>

  • Modify elements using ElementModifier.enable.

    Type Parameters

    • const FlagsT extends ElementFlags<Of<{
          attributes: {
              mask: Attribute<number, any>;
              state: Attribute<number, any>;
              supported: FixedAttribute<number, any>;
          };
          events: {
              notify: Event<TypeFromFields<{
                  active: FieldType<number>;
                  inactive: FieldType<number>;
                  mask: FieldType<number>;
                  state: FieldType<number>;
              }>, any>;
          };
          extensions: readonly [{
              component: {
                  attributes: {
                      latch: FixedAttribute<number, any>;
                  };
                  commands: {
                      reset: Command<TypeFromFields<{
                          alarms: FieldType<(...)>;
                      }>, void, any>;
                  };
              };
              flags: {
                  reset: true;
              };
          }, {
              component: false;
              flags: {
                  reset: true;
              };
          }];
          features: {
              reset: BitFlag;
          };
          id: 87;
          name: "RefrigeratorAlarm";
          revision: 1;
      }>>

    Parameters

    Returns WithFlags<Of<{
        attributes: {
            mask: Attribute<number, any>;
            state: Attribute<number, any>;
            supported: FixedAttribute<number, any>;
        };
        events: {
            notify: Event<TypeFromFields<{
                active: FieldType<number>;
                inactive: FieldType<number>;
                mask: FieldType<number>;
                state: FieldType<number>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    latch: FixedAttribute<number, any>;
                };
                commands: {
                    reset: Command<TypeFromFields<{
                        alarms: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                reset: true;
            };
        }, {
            component: false;
            flags: {
                reset: true;
            };
        }];
        features: {
            reset: BitFlag;
        };
        id: 87;
        name: "RefrigeratorAlarm";
        revision: 1;
    }>, FlagsT>

set

  • set<const ValuesT>(values): WithValues<Of<{
        attributes: {
            mask: Attribute<number, any>;
            state: Attribute<number, any>;
            supported: FixedAttribute<number, any>;
        };
        events: {
            notify: Event<TypeFromFields<{
                active: FieldType<number>;
                inactive: FieldType<number>;
                mask: FieldType<number>;
                state: FieldType<number>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    latch: FixedAttribute<number, any>;
                };
                commands: {
                    reset: Command<TypeFromFields<{
                        alarms: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                reset: true;
            };
        }, {
            component: false;
            flags: {
                reset: true;
            };
        }];
        features: {
            reset: BitFlag;
        };
        id: 87;
        name: "RefrigeratorAlarm";
        revision: 1;
    }>, ValuesT>

  • Modify elements using ElementModifier.set.

    Type Parameters

    • const ValuesT extends {
          mask: number;
          state: number;
          supported: number;
      }

    Parameters

    Returns WithValues<Of<{
        attributes: {
            mask: Attribute<number, any>;
            state: Attribute<number, any>;
            supported: FixedAttribute<number, any>;
        };
        events: {
            notify: Event<TypeFromFields<{
                active: FieldType<number>;
                inactive: FieldType<number>;
                mask: FieldType<number>;
                state: FieldType<number>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    latch: FixedAttribute<number, any>;
                };
                commands: {
                    reset: Command<TypeFromFields<{
                        alarms: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                reset: true;
            };
        }, {
            component: false;
            flags: {
                reset: true;
            };
        }];
        features: {
            reset: BitFlag;
        };
        id: 87;
        name: "RefrigeratorAlarm";
        revision: 1;
    }>, ValuesT>

with

  • with<const SelectionT>(...selection): Of<Of<{
        attributes: {
            mask: Attribute<number, any>;
            state: Attribute<number, any>;
            supported: FixedAttribute<number, any>;
        };
        events: {
            notify: Event<TypeFromFields<{
                active: FieldType<number>;
                inactive: FieldType<number>;
                mask: FieldType<number>;
                state: FieldType<number>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    latch: FixedAttribute<number, any>;
                };
                commands: {
                    reset: Command<TypeFromFields<{
                        alarms: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                reset: true;
            };
        }, {
            component: false;
            flags: {
                reset: true;
            };
        }];
        features: {
            reset: BitFlag;
        };
        id: 87;
        name: "RefrigeratorAlarm";
        revision: 1;
    }>, SelectionT>

  • Select features using ClusterComposer.compose.

    Type Parameters

    • const SelectionT extends FeatureSelection<Of<{
          attributes: {
              mask: Attribute<number, any>;
              state: Attribute<number, any>;
              supported: FixedAttribute<number, any>;
          };
          events: {
              notify: Event<TypeFromFields<{
                  active: FieldType<number>;
                  inactive: FieldType<number>;
                  mask: FieldType<number>;
                  state: FieldType<number>;
              }>, any>;
          };
          extensions: readonly [{
              component: {
                  attributes: {
                      latch: FixedAttribute<number, any>;
                  };
                  commands: {
                      reset: Command<TypeFromFields<{
                          alarms: FieldType<(...)>;
                      }>, void, any>;
                  };
              };
              flags: {
                  reset: true;
              };
          }, {
              component: false;
              flags: {
                  reset: true;
              };
          }];
          features: {
              reset: BitFlag;
          };
          id: 87;
          name: "RefrigeratorAlarm";
          revision: 1;
      }>>

    Parameters

    Returns Of<Of<{
        attributes: {
            mask: Attribute<number, any>;
            state: Attribute<number, any>;
            supported: FixedAttribute<number, any>;
        };
        events: {
            notify: Event<TypeFromFields<{
                active: FieldType<number>;
                inactive: FieldType<number>;
                mask: FieldType<number>;
                state: FieldType<number>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    latch: FixedAttribute<number, any>;
                };
                commands: {
                    reset: Command<TypeFromFields<{
                        alarms: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                reset: true;
            };
        }, {
            component: false;
            flags: {
                reset: true;
            };
        }];
        features: {
            reset: BitFlag;
        };
        id: 87;
        name: "RefrigeratorAlarm";
        revision: 1;
    }>, SelectionT>

Settings

Member Visibility

On This Page

Properties
Methods