Interface Complete

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 base commands events extensions features id name revision supportedFeatures unknown

Methods

alter enable set with

Properties

attributes

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

base: undefined

commands

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

events: {}

extensions

extensions: undefined

features

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.

    See

    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.

    See

    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.

    See

    MatterSpecification.v13.Core § 9.17.4.2

id

id: Branded<Branded<70, "ClusterId">, "ClusterId">

name

name

revision

revision

supportedFeatures

supportedFeatures: {}

unknown

unknown

Methods

alter

  • alter<const AlterationsT>(alterations): 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.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>

enable

  • enable<const FlagsT>(flags): 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.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>

set

  • set<const ValuesT>(values): 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>

  • 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>

with

  • with<const SelectionT>(...selection): 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>

  • 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>

Settings

Member Visibility

On This Page

Properties
Methods