Interface Complete

This cluster supports all Descriptor features. It may support illegal feature combinations.

If you use this cluster you must manually specify which features are active and ensure the set of active features is legal per the Matter specification.

interface Complete {
    attributes: Merge<{
        acceptedCommandList: Attribute<CommandId[], never>;
        attributeList: Attribute<AttributeId[], never>;
        clientList: FixedAttribute<ClusterId[], any>;
        clusterRevision: Attribute<number, never>;
        deviceTypeList: FixedAttribute<TypeFromFields<{
            deviceType: FieldType<DeviceTypeId>;
            revision: FieldType<number>;
        }>[], any>;
        featureMap: Attribute<TypeFromPartialBitSchema<{
            tagList: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        partsList: Attribute<EndpointNumber[], any>;
        serverList: FixedAttribute<ClusterId[], any>;
        tagList: FixedAttribute<TypeFromFields<{
            label: OptionalFieldType<null | string>;
            mfgCode: FieldType<null | VendorId>;
            namespaceId: FieldType<number>;
            tag: FieldType<number>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                tagList: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    }, GlobalAttributes<{
        tagList: BitFlag;
    }>>;
    base: undefined;
    commands: {};
    events: {};
    extensions: undefined;
    features: {
        tagList: BitFlag;
    };
    id: Branded<Branded<29, "ClusterId">, "ClusterId">;
    name: "Descriptor";
    revision: 2;
    supportedFeatures: {};
    unknown: false;
    alter<const AlterationsT>(alterations: AlterationsT): WithAlterations<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            clientList: FixedAttribute<ClusterId[], any>;
            clusterRevision: Attribute<number, never>;
            deviceTypeList: FixedAttribute<TypeFromFields<{
                deviceType: FieldType<DeviceTypeId>;
                revision: FieldType<number>;
            }>[], any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                tagList: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            partsList: Attribute<EndpointNumber[], any>;
            serverList: FixedAttribute<ClusterId[], any>;
            tagList: FixedAttribute<TypeFromFields<{
                label: OptionalFieldType<(...) | (...)>;
                mfgCode: FieldType<(...) | (...)>;
                namespaceId: FieldType<number>;
                tag: FieldType<number>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    tagList: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            tagList: BitFlag;
        };
        id: Branded<29, "ClusterId">;
        name: "Descriptor";
        revision: 2;
    }>, AlterationsT>;
    enable<const FlagsT>(flags: FlagsT): WithFlags<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            clientList: FixedAttribute<ClusterId[], any>;
            clusterRevision: Attribute<number, never>;
            deviceTypeList: FixedAttribute<TypeFromFields<{
                deviceType: FieldType<DeviceTypeId>;
                revision: FieldType<number>;
            }>[], any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                tagList: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            partsList: Attribute<EndpointNumber[], any>;
            serverList: FixedAttribute<ClusterId[], any>;
            tagList: FixedAttribute<TypeFromFields<{
                label: OptionalFieldType<(...) | (...)>;
                mfgCode: FieldType<(...) | (...)>;
                namespaceId: FieldType<number>;
                tag: FieldType<number>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    tagList: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            tagList: BitFlag;
        };
        id: Branded<29, "ClusterId">;
        name: "Descriptor";
        revision: 2;
    }>, FlagsT>;
    set<const ValuesT>(values: ValuesT): WithValues<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            clientList: FixedAttribute<ClusterId[], any>;
            clusterRevision: Attribute<number, never>;
            deviceTypeList: FixedAttribute<TypeFromFields<{
                deviceType: FieldType<DeviceTypeId>;
                revision: FieldType<number>;
            }>[], any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                tagList: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            partsList: Attribute<EndpointNumber[], any>;
            serverList: FixedAttribute<ClusterId[], any>;
            tagList: FixedAttribute<TypeFromFields<{
                label: OptionalFieldType<(...) | (...)>;
                mfgCode: FieldType<(...) | (...)>;
                namespaceId: FieldType<number>;
                tag: FieldType<number>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    tagList: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            tagList: BitFlag;
        };
        id: Branded<29, "ClusterId">;
        name: "Descriptor";
        revision: 2;
    }>, ValuesT>;
    with<const SelectionT>(...selection: SelectionT): Of<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            clientList: FixedAttribute<ClusterId[], any>;
            clusterRevision: Attribute<number, never>;
            deviceTypeList: FixedAttribute<TypeFromFields<{
                deviceType: FieldType<DeviceTypeId>;
                revision: FieldType<number>;
            }>[], any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                tagList: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            partsList: Attribute<EndpointNumber[], any>;
            serverList: FixedAttribute<ClusterId[], any>;
            tagList: FixedAttribute<TypeFromFields<{
                label: OptionalFieldType<(...) | (...)>;
                mfgCode: FieldType<(...) | (...)>;
                namespaceId: FieldType<number>;
                tag: FieldType<number>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    tagList: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            tagList: BitFlag;
        };
        id: Branded<29, "ClusterId">;
        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<{
    acceptedCommandList: Attribute<CommandId[], never>;
    attributeList: Attribute<AttributeId[], never>;
    clientList: FixedAttribute<ClusterId[], any>;
    clusterRevision: Attribute<number, never>;
    deviceTypeList: FixedAttribute<TypeFromFields<{
        deviceType: FieldType<DeviceTypeId>;
        revision: FieldType<number>;
    }>[], any>;
    featureMap: Attribute<TypeFromPartialBitSchema<{
        tagList: BitFlag;
    }>, never>;
    generatedCommandList: Attribute<CommandId[], never>;
    partsList: Attribute<EndpointNumber[], any>;
    serverList: FixedAttribute<ClusterId[], any>;
    tagList: FixedAttribute<TypeFromFields<{
        label: OptionalFieldType<null | string>;
        mfgCode: FieldType<null | VendorId>;
        namespaceId: FieldType<number>;
        tag: FieldType<number>;
    }>[], any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            tagList: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
}, GlobalAttributes<{
    tagList: BitFlag;
}>>

base

base: undefined

commands

commands: {}

events

events: {}

extensions

extensions: undefined

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<Branded<29, "ClusterId">, "ClusterId">

name

name

revision

revision

supportedFeatures

supportedFeatures: {}

unknown

unknown

Methods

alter

enable

set

  • set<const ValuesT>(values): WithValues<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            clientList: FixedAttribute<ClusterId[], any>;
            clusterRevision: Attribute<number, never>;
            deviceTypeList: FixedAttribute<TypeFromFields<{
                deviceType: FieldType<DeviceTypeId>;
                revision: FieldType<number>;
            }>[], any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                tagList: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            partsList: Attribute<EndpointNumber[], any>;
            serverList: FixedAttribute<ClusterId[], any>;
            tagList: FixedAttribute<TypeFromFields<{
                label: OptionalFieldType<(...) | (...)>;
                mfgCode: FieldType<(...) | (...)>;
                namespaceId: FieldType<number>;
                tag: FieldType<number>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    tagList: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            tagList: BitFlag;
        };
        id: Branded<29, "ClusterId">;
        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[];
          tagList?: {
              label?: null | string;
              mfgCode: null | number;
              namespaceId: number;
              tag: number;
          }[];
      }

    Parameters

    Returns WithValues<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            clientList: FixedAttribute<ClusterId[], any>;
            clusterRevision: Attribute<number, never>;
            deviceTypeList: FixedAttribute<TypeFromFields<{
                deviceType: FieldType<DeviceTypeId>;
                revision: FieldType<number>;
            }>[], any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                tagList: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            partsList: Attribute<EndpointNumber[], any>;
            serverList: FixedAttribute<ClusterId[], any>;
            tagList: FixedAttribute<TypeFromFields<{
                label: OptionalFieldType<(...) | (...)>;
                mfgCode: FieldType<(...) | (...)>;
                namespaceId: FieldType<number>;
                tag: FieldType<number>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    tagList: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            tagList: BitFlag;
        };
        id: Branded<29, "ClusterId">;
        name: "Descriptor";
        revision: 2;
    }>, ValuesT>

with

Settings

Member Visibility

On This Page

Properties
Methods