Interface Cluster

This cluster provides an interface for controlling a characteristic of a device that can be set to one of several predefined values. For example, the light pattern of a disco ball, the mode of a massage chair, or the wash cycle of a laundry machine.

The server allows the client to set a mode on the server. A mode is one of a list of options that may be presented by a client for a user choice, or understood by the client, via the semantic tags on the mode.

A semantic tag is either a standard tag within a standard category namespace, or a manufacturer specific tag, within the namespace of the vendor ID of the manufacturer. If there is no semantic tag, the mode is anonymous, and the selection is made by the user solely based on the Label string.

Each cluster ID that indicates this specification shall define a distinct purpose for the cluster instance. For example: A LightBlinking cluster ID supports blinking modes for a light (and is described that way).

An anonymous mode shall support the derived cluster purpose. A manufacturer specific semantic tag shall support the derived cluster purpose. An anonymous mode shall NOT replace the meaning of a standard semantic tag, when one exists, for the cluster purpose.

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

See

MatterSpecification.v13.Cluster § 1.9

interface Cluster {
    attributes: Merge<{
        currentMode: Attribute<number, any>;
        description: FixedAttribute<string, any>;
        standardNamespace: FixedAttribute<null | number, any>;
        startUpMode: OptionalWritableAttribute<null | number, any>;
        supportedModes: FixedAttribute<TypeFromFields<{
            label: FieldType<string>;
            mode: FieldType<number>;
            semanticTags: FieldType<TypeFromFields<{
                mfgCode: FieldType<(...)>;
                value: FieldType<(...)>;
            }>[]>;
        }>[], any>;
    }, GlobalAttributes<{
        onOff: BitFlag;
    }>>;
    base: undefined;
    commands: {
        changeToMode: Command<TypeFromFields<{
            newMode: FieldType<number>;
        }>, void, any>;
    };
    events: {};
    extensions: readonly [{
        component: {
            attributes: {
                onMode: WritableAttribute<null | number, any>;
            };
        };
        flags: {
            onOff: true;
        };
    }];
    features: {
        onOff: BitFlag;
    };
    id: Branded<80, "ClusterId">;
    name: "ModeSelect";
    revision: 2;
    supportedFeatures: {};
    unknown: false;
    alter<const AlterationsT>(alterations: AlterationsT): WithAlterations<Of<{
        attributes: {
            currentMode: Attribute<number, any>;
            description: FixedAttribute<string, any>;
            standardNamespace: FixedAttribute<null | number, any>;
            startUpMode: OptionalWritableAttribute<null | number, any>;
            supportedModes: FixedAttribute<TypeFromFields<{
                label: FieldType<string>;
                mode: FieldType<number>;
                semanticTags: FieldType<TypeFromFields<(...)>[]>;
            }>[], any>;
        };
        commands: {
            changeToMode: Command<TypeFromFields<{
                newMode: FieldType<number>;
            }>, void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    onMode: WritableAttribute<null | number, any>;
                };
            };
            flags: {
                onOff: true;
            };
        }];
        features: {
            onOff: BitFlag;
        };
        id: 80;
        name: "ModeSelect";
        revision: 2;
    }>, AlterationsT>;
    enable<const FlagsT>(flags: FlagsT): WithFlags<Of<{
        attributes: {
            currentMode: Attribute<number, any>;
            description: FixedAttribute<string, any>;
            standardNamespace: FixedAttribute<null | number, any>;
            startUpMode: OptionalWritableAttribute<null | number, any>;
            supportedModes: FixedAttribute<TypeFromFields<{
                label: FieldType<string>;
                mode: FieldType<number>;
                semanticTags: FieldType<TypeFromFields<(...)>[]>;
            }>[], any>;
        };
        commands: {
            changeToMode: Command<TypeFromFields<{
                newMode: FieldType<number>;
            }>, void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    onMode: WritableAttribute<null | number, any>;
                };
            };
            flags: {
                onOff: true;
            };
        }];
        features: {
            onOff: BitFlag;
        };
        id: 80;
        name: "ModeSelect";
        revision: 2;
    }>, FlagsT>;
    set<const ValuesT>(values: ValuesT): WithValues<Of<{
        attributes: {
            currentMode: Attribute<number, any>;
            description: FixedAttribute<string, any>;
            standardNamespace: FixedAttribute<null | number, any>;
            startUpMode: OptionalWritableAttribute<null | number, any>;
            supportedModes: FixedAttribute<TypeFromFields<{
                label: FieldType<string>;
                mode: FieldType<number>;
                semanticTags: FieldType<TypeFromFields<(...)>[]>;
            }>[], any>;
        };
        commands: {
            changeToMode: Command<TypeFromFields<{
                newMode: FieldType<number>;
            }>, void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    onMode: WritableAttribute<null | number, any>;
                };
            };
            flags: {
                onOff: true;
            };
        }];
        features: {
            onOff: BitFlag;
        };
        id: 80;
        name: "ModeSelect";
        revision: 2;
    }>, ValuesT>;
    with<const SelectionT>(...selection: SelectionT): Of<Of<{
        attributes: {
            currentMode: Attribute<number, any>;
            description: FixedAttribute<string, any>;
            standardNamespace: FixedAttribute<null | number, any>;
            startUpMode: OptionalWritableAttribute<null | number, any>;
            supportedModes: FixedAttribute<TypeFromFields<{
                label: FieldType<string>;
                mode: FieldType<number>;
                semanticTags: FieldType<TypeFromFields<(...)>[]>;
            }>[], any>;
        };
        commands: {
            changeToMode: Command<TypeFromFields<{
                newMode: FieldType<number>;
            }>, void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    onMode: WritableAttribute<null | number, any>;
                };
            };
            flags: {
                onOff: true;
            };
        }];
        features: {
            onOff: BitFlag;
        };
        id: 80;
        name: "ModeSelect";
        revision: 2;
    }>, 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<{
    currentMode: Attribute<number, any>;
    description: FixedAttribute<string, any>;
    standardNamespace: FixedAttribute<null | number, any>;
    startUpMode: OptionalWritableAttribute<null | number, any>;
    supportedModes: FixedAttribute<TypeFromFields<{
        label: FieldType<string>;
        mode: FieldType<number>;
        semanticTags: FieldType<TypeFromFields<{
            mfgCode: FieldType<(...)>;
            value: FieldType<(...)>;
        }>[]>;
    }>[], any>;
}, GlobalAttributes<{
    onOff: BitFlag;
}>>

Type declaration

  • ReadonlycurrentMode: Attribute<number, any>

    This attribute represents the current mode of the server.

    The value of this field must match the Mode field of one of the entries in the SupportedModes

    attribute.

    See

    MatterSpecification.v13.Cluster § 1.9.6.5

  • Readonlydescription: FixedAttribute<string, any>

    This attribute describes the purpose of the server, in readable text.

    For example, a coffee machine may have a Mode Select cluster for the amount of milk to add, and another Mode Select cluster for the amount of sugar to add. In this case, the first instance can have the description Milk and the second instance can have the description Sugar. This allows the user to tell the purpose of each of the instances.

    See

    MatterSpecification.v13.Cluster § 1.9.6.2

  • ReadonlystandardNamespace: FixedAttribute<null | number, any>

    This attribute, when not null, shall indicate a single standard namespace for any standard semantic tag value supported in this or any other cluster instance with the same value of this attribute. A

    null value indicates no standard namespace, and therefore, no standard semantic tags are provided in this cluster instance. Each standard namespace and corresponding values and value meanings shall be defined in another document.

    See

    MatterSpecification.v13.Cluster § 1.9.6.3

  • ReadonlystartUpMode: OptionalWritableAttribute<null | number, any>

    The StartUpMode attribute value indicates the desired startup mode for the server when it is supplied with power.

    If this attribute is not null, the CurrentMode attribute shall be set to the StartUpMode value, when the server is powered up, except in the case when the OnMode attribute overrides the StartUpMode attribute (see OnModeWithPowerUp).

    This behavior does not apply to reboots associated with OTA. After an OTA restart, the CurrentMode attribute shall return to its value prior to the restart.

    The value of this field shall match the Mode field of one of the entries in the SupportedModes

    attribute.

    If this attribute is not implemented, or is set to the null value, it shall have no effect.

    See

    MatterSpecification.v13.Cluster § 1.9.6.6

  • ReadonlysupportedModes: FixedAttribute<TypeFromFields<{
        label: FieldType<string>;
        mode: FieldType<number>;
        semanticTags: FieldType<TypeFromFields<{
            mfgCode: FieldType<(...)>;
            value: FieldType<(...)>;
        }>[]>;
    }>[], any>

    This attribute is the list of supported modes that may be selected for the CurrentMode attribute. Each item in this list represents a unique mode as indicated by the Mode field of the ModeOptionStruct. Each entry in this list shall have a unique value for the Mode field.

    See

    MatterSpecification.v13.Cluster § 1.9.6.4

base

base: undefined

commands

commands: {
    changeToMode: Command<TypeFromFields<{
        newMode: FieldType<number>;
    }>, void, any>;
}

Type declaration

  • ReadonlychangeToMode: Command<TypeFromFields<{
        newMode: FieldType<number>;
    }>, void, any>

    On receipt of this command, if the NewMode field indicates a valid mode transition within the supported list, the server shall set the CurrentMode attribute to the NewMode value, otherwise, the server shall respond with an INVALID_COMMAND status response.

    See

    MatterSpecification.v13.Cluster § 1.9.7.1

events

events: {}

extensions

extensions: readonly [{
    component: {
        attributes: {
            onMode: WritableAttribute<null | number, any>;
        };
    };
    flags: {
        onOff: true;
    };
}]

features

features: {
    onOff: BitFlag;
}

Type declaration

  • ReadonlyonOff: BitFlag

    OnOff

    This feature creates a dependency between an OnOff cluster instance and this cluster instance on the same endpoint. See OnMode for more information.

    See

    MatterSpecification.v13.Cluster § 1.9.4.1

id

id: Branded<80, "ClusterId">

name

name

revision

revision

supportedFeatures

supportedFeatures: {}

unknown

unknown

Methods

alter

  • alter<const AlterationsT>(alterations): WithAlterations<Of<{
        attributes: {
            currentMode: Attribute<number, any>;
            description: FixedAttribute<string, any>;
            standardNamespace: FixedAttribute<null | number, any>;
            startUpMode: OptionalWritableAttribute<null | number, any>;
            supportedModes: FixedAttribute<TypeFromFields<{
                label: FieldType<string>;
                mode: FieldType<number>;
                semanticTags: FieldType<TypeFromFields<(...)>[]>;
            }>[], any>;
        };
        commands: {
            changeToMode: Command<TypeFromFields<{
                newMode: FieldType<number>;
            }>, void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    onMode: WritableAttribute<null | number, any>;
                };
            };
            flags: {
                onOff: true;
            };
        }];
        features: {
            onOff: BitFlag;
        };
        id: 80;
        name: "ModeSelect";
        revision: 2;
    }>, AlterationsT>

  • Modify elements using ElementModifier.alter.

    Type Parameters

    • const AlterationsT extends Alterations<Of<{
          attributes: {
              currentMode: Attribute<number, any>;
              description: FixedAttribute<string, any>;
              standardNamespace: FixedAttribute<null | number, any>;
              startUpMode: OptionalWritableAttribute<null | number, any>;
              supportedModes: FixedAttribute<TypeFromFields<{
                  label: FieldType<string>;
                  mode: FieldType<number>;
                  semanticTags: FieldType<TypeFromFields<(...)>[]>;
              }>[], any>;
          };
          commands: {
              changeToMode: Command<TypeFromFields<{
                  newMode: FieldType<number>;
              }>, void, any>;
          };
          extensions: readonly [{
              component: {
                  attributes: {
                      onMode: WritableAttribute<null | number, any>;
                  };
              };
              flags: {
                  onOff: true;
              };
          }];
          features: {
              onOff: BitFlag;
          };
          id: 80;
          name: "ModeSelect";
          revision: 2;
      }>>

    Parameters

    Returns WithAlterations<Of<{
        attributes: {
            currentMode: Attribute<number, any>;
            description: FixedAttribute<string, any>;
            standardNamespace: FixedAttribute<null | number, any>;
            startUpMode: OptionalWritableAttribute<null | number, any>;
            supportedModes: FixedAttribute<TypeFromFields<{
                label: FieldType<string>;
                mode: FieldType<number>;
                semanticTags: FieldType<TypeFromFields<(...)>[]>;
            }>[], any>;
        };
        commands: {
            changeToMode: Command<TypeFromFields<{
                newMode: FieldType<number>;
            }>, void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    onMode: WritableAttribute<null | number, any>;
                };
            };
            flags: {
                onOff: true;
            };
        }];
        features: {
            onOff: BitFlag;
        };
        id: 80;
        name: "ModeSelect";
        revision: 2;
    }>, AlterationsT>

enable

  • enable<const FlagsT>(flags): WithFlags<Of<{
        attributes: {
            currentMode: Attribute<number, any>;
            description: FixedAttribute<string, any>;
            standardNamespace: FixedAttribute<null | number, any>;
            startUpMode: OptionalWritableAttribute<null | number, any>;
            supportedModes: FixedAttribute<TypeFromFields<{
                label: FieldType<string>;
                mode: FieldType<number>;
                semanticTags: FieldType<TypeFromFields<(...)>[]>;
            }>[], any>;
        };
        commands: {
            changeToMode: Command<TypeFromFields<{
                newMode: FieldType<number>;
            }>, void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    onMode: WritableAttribute<null | number, any>;
                };
            };
            flags: {
                onOff: true;
            };
        }];
        features: {
            onOff: BitFlag;
        };
        id: 80;
        name: "ModeSelect";
        revision: 2;
    }>, FlagsT>

  • Modify elements using ElementModifier.enable.

    Type Parameters

    • const FlagsT extends ElementFlags<Of<{
          attributes: {
              currentMode: Attribute<number, any>;
              description: FixedAttribute<string, any>;
              standardNamespace: FixedAttribute<null | number, any>;
              startUpMode: OptionalWritableAttribute<null | number, any>;
              supportedModes: FixedAttribute<TypeFromFields<{
                  label: FieldType<string>;
                  mode: FieldType<number>;
                  semanticTags: FieldType<TypeFromFields<(...)>[]>;
              }>[], any>;
          };
          commands: {
              changeToMode: Command<TypeFromFields<{
                  newMode: FieldType<number>;
              }>, void, any>;
          };
          extensions: readonly [{
              component: {
                  attributes: {
                      onMode: WritableAttribute<null | number, any>;
                  };
              };
              flags: {
                  onOff: true;
              };
          }];
          features: {
              onOff: BitFlag;
          };
          id: 80;
          name: "ModeSelect";
          revision: 2;
      }>>

    Parameters

    Returns WithFlags<Of<{
        attributes: {
            currentMode: Attribute<number, any>;
            description: FixedAttribute<string, any>;
            standardNamespace: FixedAttribute<null | number, any>;
            startUpMode: OptionalWritableAttribute<null | number, any>;
            supportedModes: FixedAttribute<TypeFromFields<{
                label: FieldType<string>;
                mode: FieldType<number>;
                semanticTags: FieldType<TypeFromFields<(...)>[]>;
            }>[], any>;
        };
        commands: {
            changeToMode: Command<TypeFromFields<{
                newMode: FieldType<number>;
            }>, void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    onMode: WritableAttribute<null | number, any>;
                };
            };
            flags: {
                onOff: true;
            };
        }];
        features: {
            onOff: BitFlag;
        };
        id: 80;
        name: "ModeSelect";
        revision: 2;
    }>, FlagsT>

set

  • set<const ValuesT>(values): WithValues<Of<{
        attributes: {
            currentMode: Attribute<number, any>;
            description: FixedAttribute<string, any>;
            standardNamespace: FixedAttribute<null | number, any>;
            startUpMode: OptionalWritableAttribute<null | number, any>;
            supportedModes: FixedAttribute<TypeFromFields<{
                label: FieldType<string>;
                mode: FieldType<number>;
                semanticTags: FieldType<TypeFromFields<(...)>[]>;
            }>[], any>;
        };
        commands: {
            changeToMode: Command<TypeFromFields<{
                newMode: FieldType<number>;
            }>, void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    onMode: WritableAttribute<null | number, any>;
                };
            };
            flags: {
                onOff: true;
            };
        }];
        features: {
            onOff: BitFlag;
        };
        id: 80;
        name: "ModeSelect";
        revision: 2;
    }>, ValuesT>

  • Modify elements using ElementModifier.set.

    Type Parameters

    • const ValuesT extends {
          currentMode: number;
          description: string;
          standardNamespace: null | number;
          startUpMode?: null | number;
          supportedModes: {
              label: string;
              mode: number;
              semanticTags: {
                  mfgCode: number;
                  value: number;
              }[];
          }[];
      }

    Parameters

    Returns WithValues<Of<{
        attributes: {
            currentMode: Attribute<number, any>;
            description: FixedAttribute<string, any>;
            standardNamespace: FixedAttribute<null | number, any>;
            startUpMode: OptionalWritableAttribute<null | number, any>;
            supportedModes: FixedAttribute<TypeFromFields<{
                label: FieldType<string>;
                mode: FieldType<number>;
                semanticTags: FieldType<TypeFromFields<(...)>[]>;
            }>[], any>;
        };
        commands: {
            changeToMode: Command<TypeFromFields<{
                newMode: FieldType<number>;
            }>, void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    onMode: WritableAttribute<null | number, any>;
                };
            };
            flags: {
                onOff: true;
            };
        }];
        features: {
            onOff: BitFlag;
        };
        id: 80;
        name: "ModeSelect";
        revision: 2;
    }>, ValuesT>

with

  • with<const SelectionT>(...selection): Of<Of<{
        attributes: {
            currentMode: Attribute<number, any>;
            description: FixedAttribute<string, any>;
            standardNamespace: FixedAttribute<null | number, any>;
            startUpMode: OptionalWritableAttribute<null | number, any>;
            supportedModes: FixedAttribute<TypeFromFields<{
                label: FieldType<string>;
                mode: FieldType<number>;
                semanticTags: FieldType<TypeFromFields<(...)>[]>;
            }>[], any>;
        };
        commands: {
            changeToMode: Command<TypeFromFields<{
                newMode: FieldType<number>;
            }>, void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    onMode: WritableAttribute<null | number, any>;
                };
            };
            flags: {
                onOff: true;
            };
        }];
        features: {
            onOff: BitFlag;
        };
        id: 80;
        name: "ModeSelect";
        revision: 2;
    }>, SelectionT>

  • Select features using ClusterComposer.compose.

    Type Parameters

    • const SelectionT extends FeatureSelection<Of<{
          attributes: {
              currentMode: Attribute<number, any>;
              description: FixedAttribute<string, any>;
              standardNamespace: FixedAttribute<null | number, any>;
              startUpMode: OptionalWritableAttribute<null | number, any>;
              supportedModes: FixedAttribute<TypeFromFields<{
                  label: FieldType<string>;
                  mode: FieldType<number>;
                  semanticTags: FieldType<TypeFromFields<(...)>[]>;
              }>[], any>;
          };
          commands: {
              changeToMode: Command<TypeFromFields<{
                  newMode: FieldType<number>;
              }>, void, any>;
          };
          extensions: readonly [{
              component: {
                  attributes: {
                      onMode: WritableAttribute<null | number, any>;
                  };
              };
              flags: {
                  onOff: true;
              };
          }];
          features: {
              onOff: BitFlag;
          };
          id: 80;
          name: "ModeSelect";
          revision: 2;
      }>>

    Parameters

    Returns Of<Of<{
        attributes: {
            currentMode: Attribute<number, any>;
            description: FixedAttribute<string, any>;
            standardNamespace: FixedAttribute<null | number, any>;
            startUpMode: OptionalWritableAttribute<null | number, any>;
            supportedModes: FixedAttribute<TypeFromFields<{
                label: FieldType<string>;
                mode: FieldType<number>;
                semanticTags: FieldType<TypeFromFields<(...)>[]>;
            }>[], any>;
        };
        commands: {
            changeToMode: Command<TypeFromFields<{
                newMode: FieldType<number>;
            }>, void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    onMode: WritableAttribute<null | number, any>;
                };
            };
            flags: {
                onOff: true;
            };
        }];
        features: {
            onOff: BitFlag;
        };
        id: 80;
        name: "ModeSelect";
        revision: 2;
    }>, SelectionT>

Settings

Member Visibility

On This Page

Properties
Methods