This cluster supports all IcdManagement 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>;
        activeModeDuration: FixedAttribute<number, any>;
        activeModeThreshold: FixedAttribute<number, any>;
        attributeList: Attribute<AttributeId[], never>;
        clientsSupportedPerFabric: FixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                checkInProtocolSupport: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        clusterRevision: Attribute<number, never>;
        featureMap: Attribute<TypeFromPartialBitSchema<{
            checkInProtocolSupport: BitFlag;
            longIdleTimeSupport: BitFlag;
            userActiveModeTrigger: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        icdCounter: Attribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                checkInProtocolSupport: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        idleModeDuration: FixedAttribute<number, any>;
        operatingMode: Attribute<IcdManagement.OperatingMode, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                longIdleTimeSupport: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        registeredClients: FabricScopedAttribute<TypeFromFields<{
            checkInNodeId: FieldType<NodeId>;
            fabricIndex: FieldType<FabricIndex>;
            monitoredSubject: FieldType<NodeId>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                checkInProtocolSupport: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        userActiveModeTriggerHint: FixedAttribute<TypeFromPartialBitSchema<{
            actuateSensor: BitFlag;
            actuateSensorLightsBlink: BitFlag;
            actuateSensorSeconds: BitFlag;
            actuateSensorTimes: BitFlag;
            appDefinedButton: BitFlag;
            customInstruction: BitFlag;
            deviceManual: BitFlag;
            powerCycle: BitFlag;
            resetButton: BitFlag;
            resetButtonLightsBlink: BitFlag;
            resetButtonSeconds: BitFlag;
            resetButtonTimes: BitFlag;
            settingsMenu: BitFlag;
            setupButton: BitFlag;
            setupButtonLightsBlink: BitFlag;
            setupButtonSeconds: BitFlag;
            setupButtonTimes: BitFlag;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                userActiveModeTrigger: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        userActiveModeTriggerInstruction: OptionalFixedAttribute<string, any>;
    }, GlobalAttributes<{
        checkInProtocolSupport: BitFlag;
        longIdleTimeSupport: BitFlag;
        userActiveModeTrigger: BitFlag;
    }>>;
    base: undefined;
    commands: {
        registerClient: Command<TypeFromFields<{
            checkInNodeId: FieldType<NodeId>;
            key: FieldType<Uint8Array>;
            monitoredSubject: FieldType<NodeId>;
            verificationKey: OptionalFieldType<Uint8Array>;
        }>, TypeFromFields<{
            icdCounter: FieldType<number>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                checkInProtocolSupport: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        stayActiveRequest: Command<TypeFromFields<{
            stayActiveDuration: FieldType<number>;
        }>, TypeFromFields<{
            promisedActiveDuration: FieldType<number>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                longIdleTimeSupport: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        unregisterClient: Command<TypeFromFields<{
            checkInNodeId: FieldType<NodeId>;
            verificationKey: OptionalFieldType<Uint8Array>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                checkInProtocolSupport: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    events: {};
    extensions: undefined;
    features: {
        checkInProtocolSupport: BitFlag;
        longIdleTimeSupport: BitFlag;
        userActiveModeTrigger: BitFlag;
    };
    id: Branded<Branded<70, "ClusterId">, "ClusterId">;
    name: "IcdManagement";
    revision: 2;
    supportedFeatures: {};
    unknown: false;
    alter<const AlterationsT>(alterations: AlterationsT): WithAlterations<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            activeModeDuration: FixedAttribute<number, any>;
            activeModeThreshold: FixedAttribute<number, any>;
            attributeList: Attribute<AttributeId[], never>;
            clientsSupportedPerFabric: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    checkInProtocolSupport: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clusterRevision: Attribute<number, never>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                checkInProtocolSupport: BitFlag;
                longIdleTimeSupport: BitFlag;
                userActiveModeTrigger: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            icdCounter: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    checkInProtocolSupport: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            idleModeDuration: FixedAttribute<number, any>;
            operatingMode: Attribute<IcdManagement.OperatingMode, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    longIdleTimeSupport: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            registeredClients: FabricScopedAttribute<TypeFromFields<{
                checkInNodeId: FieldType<NodeId>;
                fabricIndex: FieldType<FabricIndex>;
                monitoredSubject: FieldType<NodeId>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    checkInProtocolSupport: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            userActiveModeTriggerHint: FixedAttribute<TypeFromPartialBitSchema<{
                actuateSensor: BitFlag;
                actuateSensorLightsBlink: BitFlag;
                actuateSensorSeconds: BitFlag;
                actuateSensorTimes: BitFlag;
                appDefinedButton: BitFlag;
                customInstruction: BitFlag;
                deviceManual: BitFlag;
                powerCycle: BitFlag;
                resetButton: BitFlag;
                resetButtonLightsBlink: BitFlag;
                resetButtonSeconds: BitFlag;
                resetButtonTimes: BitFlag;
                settingsMenu: BitFlag;
                setupButton: BitFlag;
                setupButtonLightsBlink: BitFlag;
                setupButtonSeconds: BitFlag;
                setupButtonTimes: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    userActiveModeTrigger: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            userActiveModeTriggerInstruction: OptionalFixedAttribute<string, any>;
        };
        commands: {
            registerClient: Command<TypeFromFields<{
                checkInNodeId: FieldType<NodeId>;
                key: FieldType<Uint8Array>;
                monitoredSubject: FieldType<NodeId>;
                verificationKey: OptionalFieldType<Uint8Array>;
            }>, TypeFromFields<{
                icdCounter: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    checkInProtocolSupport: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            stayActiveRequest: Command<TypeFromFields<{
                stayActiveDuration: FieldType<number>;
            }>, TypeFromFields<{
                promisedActiveDuration: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    longIdleTimeSupport: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unregisterClient: Command<TypeFromFields<{
                checkInNodeId: FieldType<NodeId>;
                verificationKey: OptionalFieldType<Uint8Array>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    checkInProtocolSupport: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            checkInProtocolSupport: BitFlag;
            longIdleTimeSupport: BitFlag;
            userActiveModeTrigger: BitFlag;
        };
        id: Branded<70, "ClusterId">;
        name: "IcdManagement";
        revision: 2;
    }>, AlterationsT>;
    enable<const FlagsT>(flags: FlagsT): WithFlags<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            activeModeDuration: FixedAttribute<number, any>;
            activeModeThreshold: FixedAttribute<number, any>;
            attributeList: Attribute<AttributeId[], never>;
            clientsSupportedPerFabric: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    checkInProtocolSupport: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clusterRevision: Attribute<number, never>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                checkInProtocolSupport: BitFlag;
                longIdleTimeSupport: BitFlag;
                userActiveModeTrigger: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            icdCounter: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    checkInProtocolSupport: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            idleModeDuration: FixedAttribute<number, any>;
            operatingMode: Attribute<IcdManagement.OperatingMode, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    longIdleTimeSupport: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            registeredClients: FabricScopedAttribute<TypeFromFields<{
                checkInNodeId: FieldType<NodeId>;
                fabricIndex: FieldType<FabricIndex>;
                monitoredSubject: FieldType<NodeId>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    checkInProtocolSupport: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            userActiveModeTriggerHint: FixedAttribute<TypeFromPartialBitSchema<{
                actuateSensor: BitFlag;
                actuateSensorLightsBlink: BitFlag;
                actuateSensorSeconds: BitFlag;
                actuateSensorTimes: BitFlag;
                appDefinedButton: BitFlag;
                customInstruction: BitFlag;
                deviceManual: BitFlag;
                powerCycle: BitFlag;
                resetButton: BitFlag;
                resetButtonLightsBlink: BitFlag;
                resetButtonSeconds: BitFlag;
                resetButtonTimes: BitFlag;
                settingsMenu: BitFlag;
                setupButton: BitFlag;
                setupButtonLightsBlink: BitFlag;
                setupButtonSeconds: BitFlag;
                setupButtonTimes: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    userActiveModeTrigger: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            userActiveModeTriggerInstruction: OptionalFixedAttribute<string, any>;
        };
        commands: {
            registerClient: Command<TypeFromFields<{
                checkInNodeId: FieldType<NodeId>;
                key: FieldType<Uint8Array>;
                monitoredSubject: FieldType<NodeId>;
                verificationKey: OptionalFieldType<Uint8Array>;
            }>, TypeFromFields<{
                icdCounter: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    checkInProtocolSupport: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            stayActiveRequest: Command<TypeFromFields<{
                stayActiveDuration: FieldType<number>;
            }>, TypeFromFields<{
                promisedActiveDuration: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    longIdleTimeSupport: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unregisterClient: Command<TypeFromFields<{
                checkInNodeId: FieldType<NodeId>;
                verificationKey: OptionalFieldType<Uint8Array>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    checkInProtocolSupport: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            checkInProtocolSupport: BitFlag;
            longIdleTimeSupport: BitFlag;
            userActiveModeTrigger: BitFlag;
        };
        id: Branded<70, "ClusterId">;
        name: "IcdManagement";
        revision: 2;
    }>, FlagsT>;
    set<const ValuesT>(values: ValuesT): WithValues<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            activeModeDuration: FixedAttribute<number, any>;
            activeModeThreshold: FixedAttribute<number, any>;
            attributeList: Attribute<AttributeId[], never>;
            clientsSupportedPerFabric: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    checkInProtocolSupport: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clusterRevision: Attribute<number, never>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                checkInProtocolSupport: BitFlag;
                longIdleTimeSupport: BitFlag;
                userActiveModeTrigger: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            icdCounter: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    checkInProtocolSupport: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            idleModeDuration: FixedAttribute<number, any>;
            operatingMode: Attribute<IcdManagement.OperatingMode, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    longIdleTimeSupport: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            registeredClients: FabricScopedAttribute<TypeFromFields<{
                checkInNodeId: FieldType<NodeId>;
                fabricIndex: FieldType<FabricIndex>;
                monitoredSubject: FieldType<NodeId>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    checkInProtocolSupport: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            userActiveModeTriggerHint: FixedAttribute<TypeFromPartialBitSchema<{
                actuateSensor: BitFlag;
                actuateSensorLightsBlink: BitFlag;
                actuateSensorSeconds: BitFlag;
                actuateSensorTimes: BitFlag;
                appDefinedButton: BitFlag;
                customInstruction: BitFlag;
                deviceManual: BitFlag;
                powerCycle: BitFlag;
                resetButton: BitFlag;
                resetButtonLightsBlink: BitFlag;
                resetButtonSeconds: BitFlag;
                resetButtonTimes: BitFlag;
                settingsMenu: BitFlag;
                setupButton: BitFlag;
                setupButtonLightsBlink: BitFlag;
                setupButtonSeconds: BitFlag;
                setupButtonTimes: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    userActiveModeTrigger: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            userActiveModeTriggerInstruction: OptionalFixedAttribute<string, any>;
        };
        commands: {
            registerClient: Command<TypeFromFields<{
                checkInNodeId: FieldType<NodeId>;
                key: FieldType<Uint8Array>;
                monitoredSubject: FieldType<NodeId>;
                verificationKey: OptionalFieldType<Uint8Array>;
            }>, TypeFromFields<{
                icdCounter: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    checkInProtocolSupport: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            stayActiveRequest: Command<TypeFromFields<{
                stayActiveDuration: FieldType<number>;
            }>, TypeFromFields<{
                promisedActiveDuration: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    longIdleTimeSupport: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unregisterClient: Command<TypeFromFields<{
                checkInNodeId: FieldType<NodeId>;
                verificationKey: OptionalFieldType<Uint8Array>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    checkInProtocolSupport: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            checkInProtocolSupport: BitFlag;
            longIdleTimeSupport: BitFlag;
            userActiveModeTrigger: BitFlag;
        };
        id: Branded<70, "ClusterId">;
        name: "IcdManagement";
        revision: 2;
    }>, ValuesT>;
    with<const SelectionT>(...selection: SelectionT): Of<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            activeModeDuration: FixedAttribute<number, any>;
            activeModeThreshold: FixedAttribute<number, any>;
            attributeList: Attribute<AttributeId[], never>;
            clientsSupportedPerFabric: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    checkInProtocolSupport: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clusterRevision: Attribute<number, never>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                checkInProtocolSupport: BitFlag;
                longIdleTimeSupport: BitFlag;
                userActiveModeTrigger: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            icdCounter: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    checkInProtocolSupport: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            idleModeDuration: FixedAttribute<number, any>;
            operatingMode: Attribute<IcdManagement.OperatingMode, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    longIdleTimeSupport: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            registeredClients: FabricScopedAttribute<TypeFromFields<{
                checkInNodeId: FieldType<NodeId>;
                fabricIndex: FieldType<FabricIndex>;
                monitoredSubject: FieldType<NodeId>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    checkInProtocolSupport: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            userActiveModeTriggerHint: FixedAttribute<TypeFromPartialBitSchema<{
                actuateSensor: BitFlag;
                actuateSensorLightsBlink: BitFlag;
                actuateSensorSeconds: BitFlag;
                actuateSensorTimes: BitFlag;
                appDefinedButton: BitFlag;
                customInstruction: BitFlag;
                deviceManual: BitFlag;
                powerCycle: BitFlag;
                resetButton: BitFlag;
                resetButtonLightsBlink: BitFlag;
                resetButtonSeconds: BitFlag;
                resetButtonTimes: BitFlag;
                settingsMenu: BitFlag;
                setupButton: BitFlag;
                setupButtonLightsBlink: BitFlag;
                setupButtonSeconds: BitFlag;
                setupButtonTimes: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    userActiveModeTrigger: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            userActiveModeTriggerInstruction: OptionalFixedAttribute<string, any>;
        };
        commands: {
            registerClient: Command<TypeFromFields<{
                checkInNodeId: FieldType<NodeId>;
                key: FieldType<Uint8Array>;
                monitoredSubject: FieldType<NodeId>;
                verificationKey: OptionalFieldType<Uint8Array>;
            }>, TypeFromFields<{
                icdCounter: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    checkInProtocolSupport: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            stayActiveRequest: Command<TypeFromFields<{
                stayActiveDuration: FieldType<number>;
            }>, TypeFromFields<{
                promisedActiveDuration: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    longIdleTimeSupport: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unregisterClient: Command<TypeFromFields<{
                checkInNodeId: FieldType<NodeId>;
                verificationKey: OptionalFieldType<Uint8Array>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    checkInProtocolSupport: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            checkInProtocolSupport: BitFlag;
            longIdleTimeSupport: BitFlag;
            userActiveModeTrigger: BitFlag;
        };
        id: Branded<70, "ClusterId">;
        name: "IcdManagement";
        revision: 2;
    }>, SelectionT>;
}

Hierarchy (view full)

Properties

attributes: Merge<{
    acceptedCommandList: Attribute<CommandId[], never>;
    activeModeDuration: FixedAttribute<number, any>;
    activeModeThreshold: FixedAttribute<number, any>;
    attributeList: Attribute<AttributeId[], never>;
    clientsSupportedPerFabric: FixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            checkInProtocolSupport: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    clusterRevision: Attribute<number, never>;
    featureMap: Attribute<TypeFromPartialBitSchema<{
        checkInProtocolSupport: BitFlag;
        longIdleTimeSupport: BitFlag;
        userActiveModeTrigger: BitFlag;
    }>, never>;
    generatedCommandList: Attribute<CommandId[], never>;
    icdCounter: Attribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            checkInProtocolSupport: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    idleModeDuration: FixedAttribute<number, any>;
    operatingMode: Attribute<IcdManagement.OperatingMode, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            longIdleTimeSupport: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    registeredClients: FabricScopedAttribute<TypeFromFields<{
        checkInNodeId: FieldType<NodeId>;
        fabricIndex: FieldType<FabricIndex>;
        monitoredSubject: FieldType<NodeId>;
    }>[], any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            checkInProtocolSupport: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    userActiveModeTriggerHint: FixedAttribute<TypeFromPartialBitSchema<{
        actuateSensor: BitFlag;
        actuateSensorLightsBlink: BitFlag;
        actuateSensorSeconds: BitFlag;
        actuateSensorTimes: BitFlag;
        appDefinedButton: BitFlag;
        customInstruction: BitFlag;
        deviceManual: BitFlag;
        powerCycle: BitFlag;
        resetButton: BitFlag;
        resetButtonLightsBlink: BitFlag;
        resetButtonSeconds: BitFlag;
        resetButtonTimes: BitFlag;
        settingsMenu: BitFlag;
        setupButton: BitFlag;
        setupButtonLightsBlink: BitFlag;
        setupButtonSeconds: BitFlag;
        setupButtonTimes: BitFlag;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            userActiveModeTrigger: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    userActiveModeTriggerInstruction: OptionalFixedAttribute<string, any>;
}, GlobalAttributes<{
    checkInProtocolSupport: BitFlag;
    longIdleTimeSupport: BitFlag;
    userActiveModeTrigger: BitFlag;
}>>

Type declaration

  • ReadonlyacceptedCommandList: Attribute<CommandId[], never>

    List of client generated commands which are supported by this cluster server instance.

  • ReadonlyactiveModeDuration: FixedAttribute<number, any>

    Indicates the minimum interval in milliseconds the server typically will stay in active mode after initial transition out of idle mode. The ActiveModeDuration does not include the ActiveModeThreshold.

    MatterSpecification.v13.Core § 9.17.6.2

  • ReadonlyactiveModeThreshold: FixedAttribute<number, any>

    Indicates the minimum amount of time in milliseconds the server typically will stay active after network activity when in active mode.

    MatterSpecification.v13.Core § 9.17.6.3

  • ReadonlyattributeList: Attribute<AttributeId[], never>

    List of the attribute IDs of the attributes supported by the cluster instance.

  • ReadonlyclientsSupportedPerFabric: FixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            checkInProtocolSupport: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlyclusterRevision: Attribute<number, never>

    Indicates the revision of the server cluster specification supported by the cluster instance.

  • ReadonlyfeatureMap: Attribute<TypeFromPartialBitSchema<{
        checkInProtocolSupport: BitFlag;
        longIdleTimeSupport: BitFlag;
        userActiveModeTrigger: BitFlag;
    }>, never>

    Indicates whether the server supports zero or more optional cluster features.

  • ReadonlygeneratedCommandList: Attribute<CommandId[], never>

    List of server generated commands (server to client commands).

  • ReadonlyicdCounter: Attribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            checkInProtocolSupport: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlyidleModeDuration: FixedAttribute<number, any>

    Indicates the maximum interval in seconds the server can stay in idle mode. The IdleModeDuration shall NOT be smaller than the ActiveModeDuration.

    MatterSpecification.v13.Core § 9.17.6.1

  • ReadonlyoperatingMode: Attribute<IcdManagement.OperatingMode, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            longIdleTimeSupport: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlyregisteredClients: FabricScopedAttribute<TypeFromFields<{
        checkInNodeId: FieldType<NodeId>;
        fabricIndex: FieldType<FabricIndex>;
        monitoredSubject: FieldType<NodeId>;
    }>[], any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            checkInProtocolSupport: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlyuserActiveModeTriggerHint: FixedAttribute<TypeFromPartialBitSchema<{
        actuateSensor: BitFlag;
        actuateSensorLightsBlink: BitFlag;
        actuateSensorSeconds: BitFlag;
        actuateSensorTimes: BitFlag;
        appDefinedButton: BitFlag;
        customInstruction: BitFlag;
        deviceManual: BitFlag;
        powerCycle: BitFlag;
        resetButton: BitFlag;
        resetButtonLightsBlink: BitFlag;
        resetButtonSeconds: BitFlag;
        resetButtonTimes: BitFlag;
        settingsMenu: BitFlag;
        setupButton: BitFlag;
        setupButtonLightsBlink: BitFlag;
        setupButtonSeconds: BitFlag;
        setupButtonTimes: BitFlag;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            userActiveModeTrigger: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlyuserActiveModeTriggerInstruction: OptionalFixedAttribute<string, any>

    The meaning of the attribute is dependent upon the UserActiveModeTriggerHint attribute value, and the conformance is in indicated in the "dependency" column in UserActiveModeTriggerHint table. The UserActiveModeTriggerInstruction attribute may give additional information on how to transition the device to Active Mode. If the attribute is present, the value shall be encoded as a valid UTF-8 string with a maximum length of 128 bytes. If the UserActiveModeTriggerHint has the ActuateSensorSeconds, ActuateSensorTimes, ResetButtonSeconds, ResetButtonTimes, SetupButtonSeconds or SetupButtonTimes set, the string shall consist solely of an encoding of N as a decimal

    unsigned integer using the ASCII digits 0-9, and without leading zeros.

    For example, given UserActiveModeTriggerHint="2048", ResetButtonTimes is set which indicates "Press Reset Button for N seconds". Therefore, a value of UserActiveModeTriggerInstruction="10" would indicate that N is 10 in that context.

    When CustomInstruction is set by the UserActiveModeTriggerHint attribute, indicating presence of a custom string, the ICD SHOULD perform localization (translation to user’s preferred language, as indicated in the Device’s currently configured locale). The Custom Instruction option SHOULD NOT be used by an ICD that does not have knowledge of the user’s language preference.

    ResetButtonLightsBlink or SetupButtonLightsBlink), information on color of light may be made available via the UserActiveModeTriggerInstruction attribute. When using such color indication in the UserActiveModeTriggerInstruction attribute, only basic primary and secondary colors that could unambiguously be decoded by a commissioner and understood by an end-user, but without worry of localization, SHOULD be used, e.g. white, red, green, blue, orange, yellow, purple. The length of the attribute SHOULD be kept small.

    MatterSpecification.v13.Core § 9.17.6.8

base: undefined
commands: {
    registerClient: Command<TypeFromFields<{
        checkInNodeId: FieldType<NodeId>;
        key: FieldType<Uint8Array>;
        monitoredSubject: FieldType<NodeId>;
        verificationKey: OptionalFieldType<Uint8Array>;
    }>, TypeFromFields<{
        icdCounter: FieldType<number>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            checkInProtocolSupport: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    stayActiveRequest: Command<TypeFromFields<{
        stayActiveDuration: FieldType<number>;
    }>, TypeFromFields<{
        promisedActiveDuration: FieldType<number>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            longIdleTimeSupport: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    unregisterClient: Command<TypeFromFields<{
        checkInNodeId: FieldType<NodeId>;
        verificationKey: OptionalFieldType<Uint8Array>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            checkInProtocolSupport: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
}
events: {}
extensions: undefined
features: {
    checkInProtocolSupport: BitFlag;
    longIdleTimeSupport: BitFlag;
    userActiveModeTrigger: BitFlag;
}

Type declaration

  • ReadonlycheckInProtocolSupport: BitFlag

    CheckInProtocolSupport

    When this feature is supported, the device shall support all the associated commands and attributes to properly support the Check-In Protocol.

    MatterSpecification.v13.Core § 9.17.4.1

  • ReadonlylongIdleTimeSupport: BitFlag

    LongIdleTimeSupport

    This feature is supported if and only the device is a Long Idle Time ICD.

    NOTE In this version of the specification, the support for the feature is provisional.

    MatterSpecification.v13.Core § 9.17.4.3

  • ReadonlyuserActiveModeTrigger: BitFlag

    UserActiveModeTrigger

    This feature is supported if and only if the device has a user active mode trigger.

    MatterSpecification.v13.Core § 9.17.4.2

id: Branded<Branded<70, "ClusterId">, "ClusterId">
name
revision
supportedFeatures: {}
unknown

Methods

  • Modify elements using ElementModifier.alter.

    Type Parameters

    • const AlterationsT extends Alterations<Of<{
          attributes: {
              acceptedCommandList: Attribute<CommandId[], never>;
              activeModeDuration: FixedAttribute<number, any>;
              activeModeThreshold: FixedAttribute<number, any>;
              attributeList: Attribute<AttributeId[], never>;
              clientsSupportedPerFabric: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      checkInProtocolSupport: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              clusterRevision: Attribute<number, never>;
              featureMap: Attribute<TypeFromPartialBitSchema<{
                  checkInProtocolSupport: BitFlag;
                  longIdleTimeSupport: BitFlag;
                  userActiveModeTrigger: BitFlag;
              }>, never>;
              generatedCommandList: Attribute<CommandId[], never>;
              icdCounter: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      checkInProtocolSupport: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              idleModeDuration: FixedAttribute<number, any>;
              operatingMode: Attribute<IcdManagement.OperatingMode, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      longIdleTimeSupport: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              registeredClients: FabricScopedAttribute<TypeFromFields<{
                  checkInNodeId: FieldType<NodeId>;
                  fabricIndex: FieldType<FabricIndex>;
                  monitoredSubject: FieldType<NodeId>;
              }>[], any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      checkInProtocolSupport: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              userActiveModeTriggerHint: FixedAttribute<TypeFromPartialBitSchema<{
                  actuateSensor: BitFlag;
                  actuateSensorLightsBlink: BitFlag;
                  actuateSensorSeconds: BitFlag;
                  actuateSensorTimes: BitFlag;
                  appDefinedButton: BitFlag;
                  customInstruction: BitFlag;
                  deviceManual: BitFlag;
                  powerCycle: BitFlag;
                  resetButton: BitFlag;
                  resetButtonLightsBlink: BitFlag;
                  resetButtonSeconds: BitFlag;
                  resetButtonTimes: BitFlag;
                  settingsMenu: BitFlag;
                  setupButton: BitFlag;
                  setupButtonLightsBlink: BitFlag;
                  setupButtonSeconds: BitFlag;
                  setupButtonTimes: BitFlag;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      userActiveModeTrigger: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              userActiveModeTriggerInstruction: OptionalFixedAttribute<string, any>;
          };
          commands: {
              registerClient: Command<TypeFromFields<{
                  checkInNodeId: FieldType<NodeId>;
                  key: FieldType<Uint8Array>;
                  monitoredSubject: FieldType<NodeId>;
                  verificationKey: OptionalFieldType<Uint8Array>;
              }>, TypeFromFields<{
                  icdCounter: FieldType<number>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      checkInProtocolSupport: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              stayActiveRequest: Command<TypeFromFields<{
                  stayActiveDuration: FieldType<number>;
              }>, TypeFromFields<{
                  promisedActiveDuration: FieldType<number>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      longIdleTimeSupport: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              unregisterClient: Command<TypeFromFields<{
                  checkInNodeId: FieldType<NodeId>;
                  verificationKey: OptionalFieldType<Uint8Array>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      checkInProtocolSupport: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          features: {
              checkInProtocolSupport: BitFlag;
              longIdleTimeSupport: BitFlag;
              userActiveModeTrigger: BitFlag;
          };
          id: Branded<70, "ClusterId">;
          name: "IcdManagement";
          revision: 2;
      }>>

    Parameters

    Returns WithAlterations<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            activeModeDuration: FixedAttribute<number, any>;
            activeModeThreshold: FixedAttribute<number, any>;
            attributeList: Attribute<AttributeId[], never>;
            clientsSupportedPerFabric: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    checkInProtocolSupport: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clusterRevision: Attribute<number, never>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                checkInProtocolSupport: BitFlag;
                longIdleTimeSupport: BitFlag;
                userActiveModeTrigger: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            icdCounter: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    checkInProtocolSupport: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            idleModeDuration: FixedAttribute<number, any>;
            operatingMode: Attribute<IcdManagement.OperatingMode, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    longIdleTimeSupport: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            registeredClients: FabricScopedAttribute<TypeFromFields<{
                checkInNodeId: FieldType<NodeId>;
                fabricIndex: FieldType<FabricIndex>;
                monitoredSubject: FieldType<NodeId>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    checkInProtocolSupport: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            userActiveModeTriggerHint: FixedAttribute<TypeFromPartialBitSchema<{
                actuateSensor: BitFlag;
                actuateSensorLightsBlink: BitFlag;
                actuateSensorSeconds: BitFlag;
                actuateSensorTimes: BitFlag;
                appDefinedButton: BitFlag;
                customInstruction: BitFlag;
                deviceManual: BitFlag;
                powerCycle: BitFlag;
                resetButton: BitFlag;
                resetButtonLightsBlink: BitFlag;
                resetButtonSeconds: BitFlag;
                resetButtonTimes: BitFlag;
                settingsMenu: BitFlag;
                setupButton: BitFlag;
                setupButtonLightsBlink: BitFlag;
                setupButtonSeconds: BitFlag;
                setupButtonTimes: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    userActiveModeTrigger: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            userActiveModeTriggerInstruction: OptionalFixedAttribute<string, any>;
        };
        commands: {
            registerClient: Command<TypeFromFields<{
                checkInNodeId: FieldType<NodeId>;
                key: FieldType<Uint8Array>;
                monitoredSubject: FieldType<NodeId>;
                verificationKey: OptionalFieldType<Uint8Array>;
            }>, TypeFromFields<{
                icdCounter: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    checkInProtocolSupport: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            stayActiveRequest: Command<TypeFromFields<{
                stayActiveDuration: FieldType<number>;
            }>, TypeFromFields<{
                promisedActiveDuration: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    longIdleTimeSupport: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unregisterClient: Command<TypeFromFields<{
                checkInNodeId: FieldType<NodeId>;
                verificationKey: OptionalFieldType<Uint8Array>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    checkInProtocolSupport: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            checkInProtocolSupport: BitFlag;
            longIdleTimeSupport: BitFlag;
            userActiveModeTrigger: BitFlag;
        };
        id: Branded<70, "ClusterId">;
        name: "IcdManagement";
        revision: 2;
    }>, AlterationsT>

  • Modify elements using ElementModifier.enable.

    Type Parameters

    • const FlagsT extends ElementFlags<Of<{
          attributes: {
              acceptedCommandList: Attribute<CommandId[], never>;
              activeModeDuration: FixedAttribute<number, any>;
              activeModeThreshold: FixedAttribute<number, any>;
              attributeList: Attribute<AttributeId[], never>;
              clientsSupportedPerFabric: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      checkInProtocolSupport: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              clusterRevision: Attribute<number, never>;
              featureMap: Attribute<TypeFromPartialBitSchema<{
                  checkInProtocolSupport: BitFlag;
                  longIdleTimeSupport: BitFlag;
                  userActiveModeTrigger: BitFlag;
              }>, never>;
              generatedCommandList: Attribute<CommandId[], never>;
              icdCounter: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      checkInProtocolSupport: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              idleModeDuration: FixedAttribute<number, any>;
              operatingMode: Attribute<IcdManagement.OperatingMode, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      longIdleTimeSupport: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              registeredClients: FabricScopedAttribute<TypeFromFields<{
                  checkInNodeId: FieldType<NodeId>;
                  fabricIndex: FieldType<FabricIndex>;
                  monitoredSubject: FieldType<NodeId>;
              }>[], any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      checkInProtocolSupport: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              userActiveModeTriggerHint: FixedAttribute<TypeFromPartialBitSchema<{
                  actuateSensor: BitFlag;
                  actuateSensorLightsBlink: BitFlag;
                  actuateSensorSeconds: BitFlag;
                  actuateSensorTimes: BitFlag;
                  appDefinedButton: BitFlag;
                  customInstruction: BitFlag;
                  deviceManual: BitFlag;
                  powerCycle: BitFlag;
                  resetButton: BitFlag;
                  resetButtonLightsBlink: BitFlag;
                  resetButtonSeconds: BitFlag;
                  resetButtonTimes: BitFlag;
                  settingsMenu: BitFlag;
                  setupButton: BitFlag;
                  setupButtonLightsBlink: BitFlag;
                  setupButtonSeconds: BitFlag;
                  setupButtonTimes: BitFlag;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      userActiveModeTrigger: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              userActiveModeTriggerInstruction: OptionalFixedAttribute<string, any>;
          };
          commands: {
              registerClient: Command<TypeFromFields<{
                  checkInNodeId: FieldType<NodeId>;
                  key: FieldType<Uint8Array>;
                  monitoredSubject: FieldType<NodeId>;
                  verificationKey: OptionalFieldType<Uint8Array>;
              }>, TypeFromFields<{
                  icdCounter: FieldType<number>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      checkInProtocolSupport: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              stayActiveRequest: Command<TypeFromFields<{
                  stayActiveDuration: FieldType<number>;
              }>, TypeFromFields<{
                  promisedActiveDuration: FieldType<number>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      longIdleTimeSupport: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              unregisterClient: Command<TypeFromFields<{
                  checkInNodeId: FieldType<NodeId>;
                  verificationKey: OptionalFieldType<Uint8Array>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      checkInProtocolSupport: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          features: {
              checkInProtocolSupport: BitFlag;
              longIdleTimeSupport: BitFlag;
              userActiveModeTrigger: BitFlag;
          };
          id: Branded<70, "ClusterId">;
          name: "IcdManagement";
          revision: 2;
      }>>

    Parameters

    Returns WithFlags<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            activeModeDuration: FixedAttribute<number, any>;
            activeModeThreshold: FixedAttribute<number, any>;
            attributeList: Attribute<AttributeId[], never>;
            clientsSupportedPerFabric: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    checkInProtocolSupport: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clusterRevision: Attribute<number, never>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                checkInProtocolSupport: BitFlag;
                longIdleTimeSupport: BitFlag;
                userActiveModeTrigger: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            icdCounter: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    checkInProtocolSupport: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            idleModeDuration: FixedAttribute<number, any>;
            operatingMode: Attribute<IcdManagement.OperatingMode, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    longIdleTimeSupport: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            registeredClients: FabricScopedAttribute<TypeFromFields<{
                checkInNodeId: FieldType<NodeId>;
                fabricIndex: FieldType<FabricIndex>;
                monitoredSubject: FieldType<NodeId>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    checkInProtocolSupport: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            userActiveModeTriggerHint: FixedAttribute<TypeFromPartialBitSchema<{
                actuateSensor: BitFlag;
                actuateSensorLightsBlink: BitFlag;
                actuateSensorSeconds: BitFlag;
                actuateSensorTimes: BitFlag;
                appDefinedButton: BitFlag;
                customInstruction: BitFlag;
                deviceManual: BitFlag;
                powerCycle: BitFlag;
                resetButton: BitFlag;
                resetButtonLightsBlink: BitFlag;
                resetButtonSeconds: BitFlag;
                resetButtonTimes: BitFlag;
                settingsMenu: BitFlag;
                setupButton: BitFlag;
                setupButtonLightsBlink: BitFlag;
                setupButtonSeconds: BitFlag;
                setupButtonTimes: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    userActiveModeTrigger: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            userActiveModeTriggerInstruction: OptionalFixedAttribute<string, any>;
        };
        commands: {
            registerClient: Command<TypeFromFields<{
                checkInNodeId: FieldType<NodeId>;
                key: FieldType<Uint8Array>;
                monitoredSubject: FieldType<NodeId>;
                verificationKey: OptionalFieldType<Uint8Array>;
            }>, TypeFromFields<{
                icdCounter: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    checkInProtocolSupport: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            stayActiveRequest: Command<TypeFromFields<{
                stayActiveDuration: FieldType<number>;
            }>, TypeFromFields<{
                promisedActiveDuration: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    longIdleTimeSupport: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unregisterClient: Command<TypeFromFields<{
                checkInNodeId: FieldType<NodeId>;
                verificationKey: OptionalFieldType<Uint8Array>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    checkInProtocolSupport: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            checkInProtocolSupport: BitFlag;
            longIdleTimeSupport: BitFlag;
            userActiveModeTrigger: BitFlag;
        };
        id: Branded<70, "ClusterId">;
        name: "IcdManagement";
        revision: 2;
    }>, FlagsT>

  • Modify elements using ElementModifier.set.

    Type Parameters

    • const ValuesT extends {
          activeModeDuration: number;
          activeModeThreshold: number;
          clientsSupportedPerFabric?: number;
          icdCounter?: number;
          idleModeDuration: number;
          operatingMode?: number;
          registeredClients?: {
              checkInNodeId: bigint;
              fabricIndex: number;
              monitoredSubject: bigint;
          }[];
          userActiveModeTriggerHint?: {
              actuateSensor?: boolean;
              actuateSensorLightsBlink?: boolean;
              actuateSensorSeconds?: boolean;
              actuateSensorTimes?: boolean;
              appDefinedButton?: boolean;
              customInstruction?: boolean;
              deviceManual?: boolean;
              powerCycle?: boolean;
              resetButton?: boolean;
              resetButtonLightsBlink?: boolean;
              resetButtonSeconds?: boolean;
              resetButtonTimes?: boolean;
              settingsMenu?: boolean;
              setupButton?: boolean;
              setupButtonLightsBlink?: boolean;
              setupButtonSeconds?: boolean;
              setupButtonTimes?: boolean;
          };
          userActiveModeTriggerInstruction?: string;
      }

    Parameters

    Returns WithValues<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            activeModeDuration: FixedAttribute<number, any>;
            activeModeThreshold: FixedAttribute<number, any>;
            attributeList: Attribute<AttributeId[], never>;
            clientsSupportedPerFabric: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    checkInProtocolSupport: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clusterRevision: Attribute<number, never>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                checkInProtocolSupport: BitFlag;
                longIdleTimeSupport: BitFlag;
                userActiveModeTrigger: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            icdCounter: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    checkInProtocolSupport: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            idleModeDuration: FixedAttribute<number, any>;
            operatingMode: Attribute<IcdManagement.OperatingMode, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    longIdleTimeSupport: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            registeredClients: FabricScopedAttribute<TypeFromFields<{
                checkInNodeId: FieldType<NodeId>;
                fabricIndex: FieldType<FabricIndex>;
                monitoredSubject: FieldType<NodeId>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    checkInProtocolSupport: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            userActiveModeTriggerHint: FixedAttribute<TypeFromPartialBitSchema<{
                actuateSensor: BitFlag;
                actuateSensorLightsBlink: BitFlag;
                actuateSensorSeconds: BitFlag;
                actuateSensorTimes: BitFlag;
                appDefinedButton: BitFlag;
                customInstruction: BitFlag;
                deviceManual: BitFlag;
                powerCycle: BitFlag;
                resetButton: BitFlag;
                resetButtonLightsBlink: BitFlag;
                resetButtonSeconds: BitFlag;
                resetButtonTimes: BitFlag;
                settingsMenu: BitFlag;
                setupButton: BitFlag;
                setupButtonLightsBlink: BitFlag;
                setupButtonSeconds: BitFlag;
                setupButtonTimes: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    userActiveModeTrigger: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            userActiveModeTriggerInstruction: OptionalFixedAttribute<string, any>;
        };
        commands: {
            registerClient: Command<TypeFromFields<{
                checkInNodeId: FieldType<NodeId>;
                key: FieldType<Uint8Array>;
                monitoredSubject: FieldType<NodeId>;
                verificationKey: OptionalFieldType<Uint8Array>;
            }>, TypeFromFields<{
                icdCounter: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    checkInProtocolSupport: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            stayActiveRequest: Command<TypeFromFields<{
                stayActiveDuration: FieldType<number>;
            }>, TypeFromFields<{
                promisedActiveDuration: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    longIdleTimeSupport: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unregisterClient: Command<TypeFromFields<{
                checkInNodeId: FieldType<NodeId>;
                verificationKey: OptionalFieldType<Uint8Array>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    checkInProtocolSupport: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            checkInProtocolSupport: BitFlag;
            longIdleTimeSupport: BitFlag;
            userActiveModeTrigger: BitFlag;
        };
        id: Branded<70, "ClusterId">;
        name: "IcdManagement";
        revision: 2;
    }>, ValuesT>

  • Select features using ClusterComposer.compose.

    Type Parameters

    • const SelectionT extends FeatureSelection<Of<{
          attributes: {
              acceptedCommandList: Attribute<CommandId[], never>;
              activeModeDuration: FixedAttribute<number, any>;
              activeModeThreshold: FixedAttribute<number, any>;
              attributeList: Attribute<AttributeId[], never>;
              clientsSupportedPerFabric: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      checkInProtocolSupport: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              clusterRevision: Attribute<number, never>;
              featureMap: Attribute<TypeFromPartialBitSchema<{
                  checkInProtocolSupport: BitFlag;
                  longIdleTimeSupport: BitFlag;
                  userActiveModeTrigger: BitFlag;
              }>, never>;
              generatedCommandList: Attribute<CommandId[], never>;
              icdCounter: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      checkInProtocolSupport: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              idleModeDuration: FixedAttribute<number, any>;
              operatingMode: Attribute<IcdManagement.OperatingMode, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      longIdleTimeSupport: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              registeredClients: FabricScopedAttribute<TypeFromFields<{
                  checkInNodeId: FieldType<NodeId>;
                  fabricIndex: FieldType<FabricIndex>;
                  monitoredSubject: FieldType<NodeId>;
              }>[], any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      checkInProtocolSupport: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              userActiveModeTriggerHint: FixedAttribute<TypeFromPartialBitSchema<{
                  actuateSensor: BitFlag;
                  actuateSensorLightsBlink: BitFlag;
                  actuateSensorSeconds: BitFlag;
                  actuateSensorTimes: BitFlag;
                  appDefinedButton: BitFlag;
                  customInstruction: BitFlag;
                  deviceManual: BitFlag;
                  powerCycle: BitFlag;
                  resetButton: BitFlag;
                  resetButtonLightsBlink: BitFlag;
                  resetButtonSeconds: BitFlag;
                  resetButtonTimes: BitFlag;
                  settingsMenu: BitFlag;
                  setupButton: BitFlag;
                  setupButtonLightsBlink: BitFlag;
                  setupButtonSeconds: BitFlag;
                  setupButtonTimes: BitFlag;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      userActiveModeTrigger: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              userActiveModeTriggerInstruction: OptionalFixedAttribute<string, any>;
          };
          commands: {
              registerClient: Command<TypeFromFields<{
                  checkInNodeId: FieldType<NodeId>;
                  key: FieldType<Uint8Array>;
                  monitoredSubject: FieldType<NodeId>;
                  verificationKey: OptionalFieldType<Uint8Array>;
              }>, TypeFromFields<{
                  icdCounter: FieldType<number>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      checkInProtocolSupport: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              stayActiveRequest: Command<TypeFromFields<{
                  stayActiveDuration: FieldType<number>;
              }>, TypeFromFields<{
                  promisedActiveDuration: FieldType<number>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      longIdleTimeSupport: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              unregisterClient: Command<TypeFromFields<{
                  checkInNodeId: FieldType<NodeId>;
                  verificationKey: OptionalFieldType<Uint8Array>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      checkInProtocolSupport: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          features: {
              checkInProtocolSupport: BitFlag;
              longIdleTimeSupport: BitFlag;
              userActiveModeTrigger: BitFlag;
          };
          id: Branded<70, "ClusterId">;
          name: "IcdManagement";
          revision: 2;
      }>>

    Parameters

    Returns Of<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            activeModeDuration: FixedAttribute<number, any>;
            activeModeThreshold: FixedAttribute<number, any>;
            attributeList: Attribute<AttributeId[], never>;
            clientsSupportedPerFabric: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    checkInProtocolSupport: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clusterRevision: Attribute<number, never>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                checkInProtocolSupport: BitFlag;
                longIdleTimeSupport: BitFlag;
                userActiveModeTrigger: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            icdCounter: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    checkInProtocolSupport: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            idleModeDuration: FixedAttribute<number, any>;
            operatingMode: Attribute<IcdManagement.OperatingMode, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    longIdleTimeSupport: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            registeredClients: FabricScopedAttribute<TypeFromFields<{
                checkInNodeId: FieldType<NodeId>;
                fabricIndex: FieldType<FabricIndex>;
                monitoredSubject: FieldType<NodeId>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    checkInProtocolSupport: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            userActiveModeTriggerHint: FixedAttribute<TypeFromPartialBitSchema<{
                actuateSensor: BitFlag;
                actuateSensorLightsBlink: BitFlag;
                actuateSensorSeconds: BitFlag;
                actuateSensorTimes: BitFlag;
                appDefinedButton: BitFlag;
                customInstruction: BitFlag;
                deviceManual: BitFlag;
                powerCycle: BitFlag;
                resetButton: BitFlag;
                resetButtonLightsBlink: BitFlag;
                resetButtonSeconds: BitFlag;
                resetButtonTimes: BitFlag;
                settingsMenu: BitFlag;
                setupButton: BitFlag;
                setupButtonLightsBlink: BitFlag;
                setupButtonSeconds: BitFlag;
                setupButtonTimes: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    userActiveModeTrigger: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            userActiveModeTriggerInstruction: OptionalFixedAttribute<string, any>;
        };
        commands: {
            registerClient: Command<TypeFromFields<{
                checkInNodeId: FieldType<NodeId>;
                key: FieldType<Uint8Array>;
                monitoredSubject: FieldType<NodeId>;
                verificationKey: OptionalFieldType<Uint8Array>;
            }>, TypeFromFields<{
                icdCounter: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    checkInProtocolSupport: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            stayActiveRequest: Command<TypeFromFields<{
                stayActiveDuration: FieldType<number>;
            }>, TypeFromFields<{
                promisedActiveDuration: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    longIdleTimeSupport: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unregisterClient: Command<TypeFromFields<{
                checkInNodeId: FieldType<NodeId>;
                verificationKey: OptionalFieldType<Uint8Array>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    checkInProtocolSupport: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            checkInProtocolSupport: BitFlag;
            longIdleTimeSupport: BitFlag;
            userActiveModeTrigger: BitFlag;
        };
        id: Branded<70, "ClusterId">;
        name: "IcdManagement";
        revision: 2;
    }>, SelectionT>