Interface Cluster

NOTE

The Descriptor cluster is meant to replace the support from the Zigbee Device Object (ZDO) for describing a node, its endpoints and clusters.

This cluster describes an endpoint instance on the node, independently from other endpoints, but also allows composition of endpoints to conform to complex device type patterns.

This cluster supports a list of one or more device type identifiers that represent conformance to device type specifications.

The cluster supports a PartsList attribute that is a list of zero or more endpoints to support a composed device type.

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

See

MatterSpecification.v13.Core § 9.5

interface Cluster {
    attributes: Merge<{
        clientList: FixedAttribute<ClusterId[], any>;
        deviceTypeList: FixedAttribute<TypeFromFields<{
            deviceType: FieldType<DeviceTypeId>;
            revision: FieldType<number>;
        }>[], any>;
        partsList: Attribute<EndpointNumber[], any>;
        serverList: FixedAttribute<ClusterId[], any>;
    }, GlobalAttributes<{
        tagList: BitFlag;
    }>>;
    base: undefined;
    commands: {};
    events: {};
    extensions: readonly [{
        component: {
            attributes: {
                tagList: FixedAttribute<TypeFromFields<{
                    label: OptionalFieldType<null | string>;
                    mfgCode: FieldType<null | VendorId>;
                    namespaceId: FieldType<number>;
                    tag: FieldType<number>;
                }>[], any>;
            };
        };
        flags: {
            tagList: true;
        };
    }];
    features: {
        tagList: BitFlag;
    };
    id: Branded<29, "ClusterId">;
    name: "Descriptor";
    revision: 2;
    supportedFeatures: {};
    unknown: false;
    alter<const AlterationsT>(alterations: AlterationsT): WithAlterations<Of<{
        attributes: {
            clientList: FixedAttribute<ClusterId[], any>;
            deviceTypeList: FixedAttribute<TypeFromFields<{
                deviceType: FieldType<DeviceTypeId>;
                revision: FieldType<number>;
            }>[], any>;
            partsList: Attribute<EndpointNumber[], any>;
            serverList: FixedAttribute<ClusterId[], any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    tagList: FixedAttribute<TypeFromFields<{
                        label: ...;
                        mfgCode: ...;
                        namespaceId: ...;
                        tag: ...;
                    }>[], any>;
                };
            };
            flags: {
                tagList: true;
            };
        }];
        features: {
            tagList: BitFlag;
        };
        id: 29;
        name: "Descriptor";
        revision: 2;
    }>, AlterationsT>;
    enable<const FlagsT>(flags: FlagsT): WithFlags<Of<{
        attributes: {
            clientList: FixedAttribute<ClusterId[], any>;
            deviceTypeList: FixedAttribute<TypeFromFields<{
                deviceType: FieldType<DeviceTypeId>;
                revision: FieldType<number>;
            }>[], any>;
            partsList: Attribute<EndpointNumber[], any>;
            serverList: FixedAttribute<ClusterId[], any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    tagList: FixedAttribute<TypeFromFields<{
                        label: ...;
                        mfgCode: ...;
                        namespaceId: ...;
                        tag: ...;
                    }>[], any>;
                };
            };
            flags: {
                tagList: true;
            };
        }];
        features: {
            tagList: BitFlag;
        };
        id: 29;
        name: "Descriptor";
        revision: 2;
    }>, FlagsT>;
    set<const ValuesT>(values: ValuesT): WithValues<Of<{
        attributes: {
            clientList: FixedAttribute<ClusterId[], any>;
            deviceTypeList: FixedAttribute<TypeFromFields<{
                deviceType: FieldType<DeviceTypeId>;
                revision: FieldType<number>;
            }>[], any>;
            partsList: Attribute<EndpointNumber[], any>;
            serverList: FixedAttribute<ClusterId[], any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    tagList: FixedAttribute<TypeFromFields<{
                        label: ...;
                        mfgCode: ...;
                        namespaceId: ...;
                        tag: ...;
                    }>[], any>;
                };
            };
            flags: {
                tagList: true;
            };
        }];
        features: {
            tagList: BitFlag;
        };
        id: 29;
        name: "Descriptor";
        revision: 2;
    }>, ValuesT>;
    with<const SelectionT>(...selection: SelectionT): Of<Of<{
        attributes: {
            clientList: FixedAttribute<ClusterId[], any>;
            deviceTypeList: FixedAttribute<TypeFromFields<{
                deviceType: FieldType<DeviceTypeId>;
                revision: FieldType<number>;
            }>[], any>;
            partsList: Attribute<EndpointNumber[], any>;
            serverList: FixedAttribute<ClusterId[], any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    tagList: FixedAttribute<TypeFromFields<{
                        label: ...;
                        mfgCode: ...;
                        namespaceId: ...;
                        tag: ...;
                    }>[], any>;
                };
            };
            flags: {
                tagList: true;
            };
        }];
        features: {
            tagList: BitFlag;
        };
        id: 29;
        name: "Descriptor";
        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<{
    clientList: FixedAttribute<ClusterId[], any>;
    deviceTypeList: FixedAttribute<TypeFromFields<{
        deviceType: FieldType<DeviceTypeId>;
        revision: FieldType<number>;
    }>[], any>;
    partsList: Attribute<EndpointNumber[], any>;
    serverList: FixedAttribute<ClusterId[], any>;
}, GlobalAttributes<{
    tagList: BitFlag;
}>>

Type declaration

  • ReadonlyclientList: FixedAttribute<ClusterId[], any>

    This attribute shall list each cluster ID for the client clusters present on the endpoint instance.

    See

    MatterSpecification.v13.Core § 9.5.6.3

  • ReadonlydeviceTypeList: FixedAttribute<TypeFromFields<{
        deviceType: FieldType<DeviceTypeId>;
        revision: FieldType<number>;
    }>[], any>

    This is a list of device types and corresponding revisions declaring endpoint conformance (see DeviceTypeStruct). At least one device type entry shall be present.

    An endpoint shall conform to all device types listed in the DeviceTypeList. A cluster instance that is in common for more than one device type in the DeviceTypeList shall be supported as a shared cluster instance on the endpoint.

    See

    MatterSpecification.v13.Core § 9.5.6.1

  • ReadonlypartsList: Attribute<EndpointNumber[], any>

    This attribute indicates composition of the device type instance. Device type instance composition shall include the endpoints in this list.

    See Endpoint Composition for more information about which endpoints to include in this list.

    See

    MatterSpecification.v13.Core § 9.5.6.4

  • ReadonlyserverList: FixedAttribute<ClusterId[], any>

    This attribute shall list each cluster ID for the server clusters present on the endpoint instance.

    See

    MatterSpecification.v13.Core § 9.5.6.2

base

base: undefined

commands

commands: {}

events

events: {}

extensions

extensions: readonly [{
    component: {
        attributes: {
            tagList: FixedAttribute<TypeFromFields<{
                label: OptionalFieldType<null | string>;
                mfgCode: FieldType<null | VendorId>;
                namespaceId: FieldType<number>;
                tag: FieldType<number>;
            }>[], any>;
        };
    };
    flags: {
        tagList: true;
    };
}]

features

features: {
    tagList: BitFlag;
}

Type declaration

  • ReadonlytagList: BitFlag

    TagList

    See the Disambiguation section in the System Model spec for conformance requirements for this feature and the corresponding attribute.

    See

    MatterSpecification.v13.Core § 9.5.4.1

id

id: Branded<29, "ClusterId">

name

name

revision

revision

supportedFeatures

supportedFeatures: {}

unknown

unknown

Methods

alter

  • alter<const AlterationsT>(alterations): WithAlterations<Of<{
        attributes: {
            clientList: FixedAttribute<ClusterId[], any>;
            deviceTypeList: FixedAttribute<TypeFromFields<{
                deviceType: FieldType<DeviceTypeId>;
                revision: FieldType<number>;
            }>[], any>;
            partsList: Attribute<EndpointNumber[], any>;
            serverList: FixedAttribute<ClusterId[], any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    tagList: FixedAttribute<TypeFromFields<{
                        label: ...;
                        mfgCode: ...;
                        namespaceId: ...;
                        tag: ...;
                    }>[], any>;
                };
            };
            flags: {
                tagList: true;
            };
        }];
        features: {
            tagList: BitFlag;
        };
        id: 29;
        name: "Descriptor";
        revision: 2;
    }>, AlterationsT>

  • Modify elements using ElementModifier.alter.

    Type Parameters

    • const AlterationsT extends Alterations<Of<{
          attributes: {
              clientList: FixedAttribute<ClusterId[], any>;
              deviceTypeList: FixedAttribute<TypeFromFields<{
                  deviceType: FieldType<DeviceTypeId>;
                  revision: FieldType<number>;
              }>[], any>;
              partsList: Attribute<EndpointNumber[], any>;
              serverList: FixedAttribute<ClusterId[], any>;
          };
          extensions: readonly [{
              component: {
                  attributes: {
                      tagList: FixedAttribute<TypeFromFields<{
                          label: ...;
                          mfgCode: ...;
                          namespaceId: ...;
                          tag: ...;
                      }>[], any>;
                  };
              };
              flags: {
                  tagList: true;
              };
          }];
          features: {
              tagList: BitFlag;
          };
          id: 29;
          name: "Descriptor";
          revision: 2;
      }>>

    Parameters

    Returns WithAlterations<Of<{
        attributes: {
            clientList: FixedAttribute<ClusterId[], any>;
            deviceTypeList: FixedAttribute<TypeFromFields<{
                deviceType: FieldType<DeviceTypeId>;
                revision: FieldType<number>;
            }>[], any>;
            partsList: Attribute<EndpointNumber[], any>;
            serverList: FixedAttribute<ClusterId[], any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    tagList: FixedAttribute<TypeFromFields<{
                        label: ...;
                        mfgCode: ...;
                        namespaceId: ...;
                        tag: ...;
                    }>[], any>;
                };
            };
            flags: {
                tagList: true;
            };
        }];
        features: {
            tagList: BitFlag;
        };
        id: 29;
        name: "Descriptor";
        revision: 2;
    }>, AlterationsT>

enable

  • enable<const FlagsT>(flags): WithFlags<Of<{
        attributes: {
            clientList: FixedAttribute<ClusterId[], any>;
            deviceTypeList: FixedAttribute<TypeFromFields<{
                deviceType: FieldType<DeviceTypeId>;
                revision: FieldType<number>;
            }>[], any>;
            partsList: Attribute<EndpointNumber[], any>;
            serverList: FixedAttribute<ClusterId[], any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    tagList: FixedAttribute<TypeFromFields<{
                        label: ...;
                        mfgCode: ...;
                        namespaceId: ...;
                        tag: ...;
                    }>[], any>;
                };
            };
            flags: {
                tagList: true;
            };
        }];
        features: {
            tagList: BitFlag;
        };
        id: 29;
        name: "Descriptor";
        revision: 2;
    }>, FlagsT>

  • Modify elements using ElementModifier.enable.

    Type Parameters

    • const FlagsT extends ElementFlags<Of<{
          attributes: {
              clientList: FixedAttribute<ClusterId[], any>;
              deviceTypeList: FixedAttribute<TypeFromFields<{
                  deviceType: FieldType<DeviceTypeId>;
                  revision: FieldType<number>;
              }>[], any>;
              partsList: Attribute<EndpointNumber[], any>;
              serverList: FixedAttribute<ClusterId[], any>;
          };
          extensions: readonly [{
              component: {
                  attributes: {
                      tagList: FixedAttribute<TypeFromFields<{
                          label: ...;
                          mfgCode: ...;
                          namespaceId: ...;
                          tag: ...;
                      }>[], any>;
                  };
              };
              flags: {
                  tagList: true;
              };
          }];
          features: {
              tagList: BitFlag;
          };
          id: 29;
          name: "Descriptor";
          revision: 2;
      }>>

    Parameters

    Returns WithFlags<Of<{
        attributes: {
            clientList: FixedAttribute<ClusterId[], any>;
            deviceTypeList: FixedAttribute<TypeFromFields<{
                deviceType: FieldType<DeviceTypeId>;
                revision: FieldType<number>;
            }>[], any>;
            partsList: Attribute<EndpointNumber[], any>;
            serverList: FixedAttribute<ClusterId[], any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    tagList: FixedAttribute<TypeFromFields<{
                        label: ...;
                        mfgCode: ...;
                        namespaceId: ...;
                        tag: ...;
                    }>[], any>;
                };
            };
            flags: {
                tagList: true;
            };
        }];
        features: {
            tagList: BitFlag;
        };
        id: 29;
        name: "Descriptor";
        revision: 2;
    }>, FlagsT>

set

  • set<const ValuesT>(values): WithValues<Of<{
        attributes: {
            clientList: FixedAttribute<ClusterId[], any>;
            deviceTypeList: FixedAttribute<TypeFromFields<{
                deviceType: FieldType<DeviceTypeId>;
                revision: FieldType<number>;
            }>[], any>;
            partsList: Attribute<EndpointNumber[], any>;
            serverList: FixedAttribute<ClusterId[], any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    tagList: FixedAttribute<TypeFromFields<{
                        label: ...;
                        mfgCode: ...;
                        namespaceId: ...;
                        tag: ...;
                    }>[], any>;
                };
            };
            flags: {
                tagList: true;
            };
        }];
        features: {
            tagList: BitFlag;
        };
        id: 29;
        name: "Descriptor";
        revision: 2;
    }>, ValuesT>

  • Modify elements using ElementModifier.set.

    Type Parameters

    • const ValuesT extends {
          clientList: number[];
          deviceTypeList: {
              deviceType: number;
              revision: number;
          }[];
          partsList: number[];
          serverList: number[];
      }

    Parameters

    Returns WithValues<Of<{
        attributes: {
            clientList: FixedAttribute<ClusterId[], any>;
            deviceTypeList: FixedAttribute<TypeFromFields<{
                deviceType: FieldType<DeviceTypeId>;
                revision: FieldType<number>;
            }>[], any>;
            partsList: Attribute<EndpointNumber[], any>;
            serverList: FixedAttribute<ClusterId[], any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    tagList: FixedAttribute<TypeFromFields<{
                        label: ...;
                        mfgCode: ...;
                        namespaceId: ...;
                        tag: ...;
                    }>[], any>;
                };
            };
            flags: {
                tagList: true;
            };
        }];
        features: {
            tagList: BitFlag;
        };
        id: 29;
        name: "Descriptor";
        revision: 2;
    }>, ValuesT>

with

  • with<const SelectionT>(...selection): Of<Of<{
        attributes: {
            clientList: FixedAttribute<ClusterId[], any>;
            deviceTypeList: FixedAttribute<TypeFromFields<{
                deviceType: FieldType<DeviceTypeId>;
                revision: FieldType<number>;
            }>[], any>;
            partsList: Attribute<EndpointNumber[], any>;
            serverList: FixedAttribute<ClusterId[], any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    tagList: FixedAttribute<TypeFromFields<{
                        label: ...;
                        mfgCode: ...;
                        namespaceId: ...;
                        tag: ...;
                    }>[], any>;
                };
            };
            flags: {
                tagList: true;
            };
        }];
        features: {
            tagList: BitFlag;
        };
        id: 29;
        name: "Descriptor";
        revision: 2;
    }>, SelectionT>

  • Select features using ClusterComposer.compose.

    Type Parameters

    • const SelectionT extends FeatureSelection<Of<{
          attributes: {
              clientList: FixedAttribute<ClusterId[], any>;
              deviceTypeList: FixedAttribute<TypeFromFields<{
                  deviceType: FieldType<DeviceTypeId>;
                  revision: FieldType<number>;
              }>[], any>;
              partsList: Attribute<EndpointNumber[], any>;
              serverList: FixedAttribute<ClusterId[], any>;
          };
          extensions: readonly [{
              component: {
                  attributes: {
                      tagList: FixedAttribute<TypeFromFields<{
                          label: ...;
                          mfgCode: ...;
                          namespaceId: ...;
                          tag: ...;
                      }>[], any>;
                  };
              };
              flags: {
                  tagList: true;
              };
          }];
          features: {
              tagList: BitFlag;
          };
          id: 29;
          name: "Descriptor";
          revision: 2;
      }>>

    Parameters

    Returns Of<Of<{
        attributes: {
            clientList: FixedAttribute<ClusterId[], any>;
            deviceTypeList: FixedAttribute<TypeFromFields<{
                deviceType: FieldType<DeviceTypeId>;
                revision: FieldType<number>;
            }>[], any>;
            partsList: Attribute<EndpointNumber[], any>;
            serverList: FixedAttribute<ClusterId[], any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    tagList: FixedAttribute<TypeFromFields<{
                        label: ...;
                        mfgCode: ...;
                        namespaceId: ...;
                        tag: ...;
                    }>[], any>;
                };
            };
            flags: {
                tagList: true;
            };
        }];
        features: {
            tagList: BitFlag;
        };
        id: 29;
        name: "Descriptor";
        revision: 2;
    }>, SelectionT>

Settings

Member Visibility

On This Page

Properties
Methods