Interface Cluster

ICD Management Cluster enables configuration of the ICD’s behavior and ensuring that listed clients can be notified when an intermittently connected device, ICD, is available for communication.

The cluster implements the requirements of the Check-In Protocol that enables the ICD Check-In use case.

NOTE This feature is provisional.

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

See

MatterSpecification.v13.Core § 9.17

interface Cluster {
    attributes: Merge<{
        activeModeDuration: FixedAttribute<number, any>;
        activeModeThreshold: FixedAttribute<number, any>;
        idleModeDuration: FixedAttribute<number, any>;
        userActiveModeTriggerInstruction: OptionalFixedAttribute<string, any>;
    }, GlobalAttributes<{
        checkInProtocolSupport: BitFlag;
        longIdleTimeSupport: BitFlag;
        userActiveModeTrigger: BitFlag;
    }>>;
    base: undefined;
    commands: {
        stayActiveRequest: OptionalCommand<TypeFromFields<{
            stayActiveDuration: FieldType<number>;
        }>, TypeFromFields<{
            promisedActiveDuration: FieldType<number>;
        }>, any>;
    };
    events: {};
    extensions: readonly [{
        component: {
            attributes: {
                clientsSupportedPerFabric: FixedAttribute<number, any>;
                icdCounter: Attribute<number, any>;
                registeredClients: FabricScopedAttribute<TypeFromFields<{
                    checkInNodeId: FieldType<NodeId>;
                    fabricIndex: FieldType<FabricIndex>;
                    monitoredSubject: FieldType<NodeId>;
                }>[], any>;
            };
            commands: {
                registerClient: Command<TypeFromFields<{
                    checkInNodeId: FieldType<NodeId>;
                    key: FieldType<Uint8Array>;
                    monitoredSubject: FieldType<NodeId>;
                    verificationKey: OptionalFieldType<Uint8Array>;
                }>, TypeFromFields<{
                    icdCounter: FieldType<number>;
                }>, any>;
                unregisterClient: Command<TypeFromFields<{
                    checkInNodeId: FieldType<NodeId>;
                    verificationKey: OptionalFieldType<Uint8Array>;
                }>, void, any>;
            };
        };
        flags: {
            checkInProtocolSupport: true;
        };
    }, {
        component: {
            attributes: {
                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>;
            };
        };
        flags: {
            userActiveModeTrigger: true;
        };
    }, {
        component: {
            attributes: {
                operatingMode: Attribute<IcdManagement.OperatingMode, any>;
            };
            commands: {
                stayActiveRequest: Command<TypeFromFields<{
                    stayActiveDuration: FieldType<number>;
                }>, TypeFromFields<{
                    promisedActiveDuration: FieldType<number>;
                }>, any>;
            };
        };
        flags: {
            longIdleTimeSupport: true;
        };
    }, {
        component: false;
        flags: {
            checkInProtocolSupport: false;
            longIdleTimeSupport: true;
        };
    }, {
        component: false;
        flags: {
            longIdleTimeSupport: true;
            userActiveModeTrigger: false;
        };
    }];
    features: {
        checkInProtocolSupport: BitFlag;
        longIdleTimeSupport: BitFlag;
        userActiveModeTrigger: BitFlag;
    };
    id: Branded<70, "ClusterId">;
    name: "IcdManagement";
    revision: 2;
    supportedFeatures: {};
    unknown: false;
    alter<const AlterationsT>(alterations: AlterationsT): WithAlterations<Of<{
        attributes: {
            activeModeDuration: FixedAttribute<number, any>;
            activeModeThreshold: FixedAttribute<number, any>;
            idleModeDuration: FixedAttribute<number, any>;
            userActiveModeTriggerInstruction: OptionalFixedAttribute<string, any>;
        };
        commands: {
            stayActiveRequest: OptionalCommand<TypeFromFields<{
                stayActiveDuration: FieldType<number>;
            }>, TypeFromFields<{
                promisedActiveDuration: FieldType<number>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    clientsSupportedPerFabric: FixedAttribute<number, any>;
                    icdCounter: Attribute<number, any>;
                    registeredClients: FabricScopedAttribute<TypeFromFields<{
                        checkInNodeId: ...;
                        fabricIndex: ...;
                        monitoredSubject: ...;
                    }>[], any>;
                };
                commands: {
                    registerClient: Command<TypeFromFields<{
                        checkInNodeId: FieldType<(...)>;
                        key: FieldType<(...)>;
                        monitoredSubject: FieldType<(...)>;
                        verificationKey: OptionalFieldType<(...)>;
                    }>, TypeFromFields<{
                        icdCounter: FieldType<(...)>;
                    }>, any>;
                    unregisterClient: Command<TypeFromFields<{
                        checkInNodeId: FieldType<(...)>;
                        verificationKey: OptionalFieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                checkInProtocolSupport: true;
            };
        }, {
            component: {
                attributes: {
                    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>;
                };
            };
            flags: {
                userActiveModeTrigger: true;
            };
        }, {
            component: {
                attributes: {
                    operatingMode: Attribute<IcdManagement.OperatingMode, any>;
                };
                commands: {
                    stayActiveRequest: Command<TypeFromFields<{
                        stayActiveDuration: FieldType<(...)>;
                    }>, TypeFromFields<{
                        promisedActiveDuration: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                longIdleTimeSupport: true;
            };
        }, {
            component: false;
            flags: {
                checkInProtocolSupport: false;
                longIdleTimeSupport: true;
            };
        }, {
            component: false;
            flags: {
                longIdleTimeSupport: true;
                userActiveModeTrigger: false;
            };
        }];
        features: {
            checkInProtocolSupport: BitFlag;
            longIdleTimeSupport: BitFlag;
            userActiveModeTrigger: BitFlag;
        };
        id: 70;
        name: "IcdManagement";
        revision: 2;
    }>, AlterationsT>;
    enable<const FlagsT>(flags: FlagsT): WithFlags<Of<{
        attributes: {
            activeModeDuration: FixedAttribute<number, any>;
            activeModeThreshold: FixedAttribute<number, any>;
            idleModeDuration: FixedAttribute<number, any>;
            userActiveModeTriggerInstruction: OptionalFixedAttribute<string, any>;
        };
        commands: {
            stayActiveRequest: OptionalCommand<TypeFromFields<{
                stayActiveDuration: FieldType<number>;
            }>, TypeFromFields<{
                promisedActiveDuration: FieldType<number>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    clientsSupportedPerFabric: FixedAttribute<number, any>;
                    icdCounter: Attribute<number, any>;
                    registeredClients: FabricScopedAttribute<TypeFromFields<{
                        checkInNodeId: ...;
                        fabricIndex: ...;
                        monitoredSubject: ...;
                    }>[], any>;
                };
                commands: {
                    registerClient: Command<TypeFromFields<{
                        checkInNodeId: FieldType<(...)>;
                        key: FieldType<(...)>;
                        monitoredSubject: FieldType<(...)>;
                        verificationKey: OptionalFieldType<(...)>;
                    }>, TypeFromFields<{
                        icdCounter: FieldType<(...)>;
                    }>, any>;
                    unregisterClient: Command<TypeFromFields<{
                        checkInNodeId: FieldType<(...)>;
                        verificationKey: OptionalFieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                checkInProtocolSupport: true;
            };
        }, {
            component: {
                attributes: {
                    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>;
                };
            };
            flags: {
                userActiveModeTrigger: true;
            };
        }, {
            component: {
                attributes: {
                    operatingMode: Attribute<IcdManagement.OperatingMode, any>;
                };
                commands: {
                    stayActiveRequest: Command<TypeFromFields<{
                        stayActiveDuration: FieldType<(...)>;
                    }>, TypeFromFields<{
                        promisedActiveDuration: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                longIdleTimeSupport: true;
            };
        }, {
            component: false;
            flags: {
                checkInProtocolSupport: false;
                longIdleTimeSupport: true;
            };
        }, {
            component: false;
            flags: {
                longIdleTimeSupport: true;
                userActiveModeTrigger: false;
            };
        }];
        features: {
            checkInProtocolSupport: BitFlag;
            longIdleTimeSupport: BitFlag;
            userActiveModeTrigger: BitFlag;
        };
        id: 70;
        name: "IcdManagement";
        revision: 2;
    }>, FlagsT>;
    set<const ValuesT>(values: ValuesT): WithValues<Of<{
        attributes: {
            activeModeDuration: FixedAttribute<number, any>;
            activeModeThreshold: FixedAttribute<number, any>;
            idleModeDuration: FixedAttribute<number, any>;
            userActiveModeTriggerInstruction: OptionalFixedAttribute<string, any>;
        };
        commands: {
            stayActiveRequest: OptionalCommand<TypeFromFields<{
                stayActiveDuration: FieldType<number>;
            }>, TypeFromFields<{
                promisedActiveDuration: FieldType<number>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    clientsSupportedPerFabric: FixedAttribute<number, any>;
                    icdCounter: Attribute<number, any>;
                    registeredClients: FabricScopedAttribute<TypeFromFields<{
                        checkInNodeId: ...;
                        fabricIndex: ...;
                        monitoredSubject: ...;
                    }>[], any>;
                };
                commands: {
                    registerClient: Command<TypeFromFields<{
                        checkInNodeId: FieldType<(...)>;
                        key: FieldType<(...)>;
                        monitoredSubject: FieldType<(...)>;
                        verificationKey: OptionalFieldType<(...)>;
                    }>, TypeFromFields<{
                        icdCounter: FieldType<(...)>;
                    }>, any>;
                    unregisterClient: Command<TypeFromFields<{
                        checkInNodeId: FieldType<(...)>;
                        verificationKey: OptionalFieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                checkInProtocolSupport: true;
            };
        }, {
            component: {
                attributes: {
                    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>;
                };
            };
            flags: {
                userActiveModeTrigger: true;
            };
        }, {
            component: {
                attributes: {
                    operatingMode: Attribute<IcdManagement.OperatingMode, any>;
                };
                commands: {
                    stayActiveRequest: Command<TypeFromFields<{
                        stayActiveDuration: FieldType<(...)>;
                    }>, TypeFromFields<{
                        promisedActiveDuration: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                longIdleTimeSupport: true;
            };
        }, {
            component: false;
            flags: {
                checkInProtocolSupport: false;
                longIdleTimeSupport: true;
            };
        }, {
            component: false;
            flags: {
                longIdleTimeSupport: true;
                userActiveModeTrigger: false;
            };
        }];
        features: {
            checkInProtocolSupport: BitFlag;
            longIdleTimeSupport: BitFlag;
            userActiveModeTrigger: BitFlag;
        };
        id: 70;
        name: "IcdManagement";
        revision: 2;
    }>, ValuesT>;
    with<const SelectionT>(...selection: SelectionT): Of<Of<{
        attributes: {
            activeModeDuration: FixedAttribute<number, any>;
            activeModeThreshold: FixedAttribute<number, any>;
            idleModeDuration: FixedAttribute<number, any>;
            userActiveModeTriggerInstruction: OptionalFixedAttribute<string, any>;
        };
        commands: {
            stayActiveRequest: OptionalCommand<TypeFromFields<{
                stayActiveDuration: FieldType<number>;
            }>, TypeFromFields<{
                promisedActiveDuration: FieldType<number>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    clientsSupportedPerFabric: FixedAttribute<number, any>;
                    icdCounter: Attribute<number, any>;
                    registeredClients: FabricScopedAttribute<TypeFromFields<{
                        checkInNodeId: ...;
                        fabricIndex: ...;
                        monitoredSubject: ...;
                    }>[], any>;
                };
                commands: {
                    registerClient: Command<TypeFromFields<{
                        checkInNodeId: FieldType<(...)>;
                        key: FieldType<(...)>;
                        monitoredSubject: FieldType<(...)>;
                        verificationKey: OptionalFieldType<(...)>;
                    }>, TypeFromFields<{
                        icdCounter: FieldType<(...)>;
                    }>, any>;
                    unregisterClient: Command<TypeFromFields<{
                        checkInNodeId: FieldType<(...)>;
                        verificationKey: OptionalFieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                checkInProtocolSupport: true;
            };
        }, {
            component: {
                attributes: {
                    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>;
                };
            };
            flags: {
                userActiveModeTrigger: true;
            };
        }, {
            component: {
                attributes: {
                    operatingMode: Attribute<IcdManagement.OperatingMode, any>;
                };
                commands: {
                    stayActiveRequest: Command<TypeFromFields<{
                        stayActiveDuration: FieldType<(...)>;
                    }>, TypeFromFields<{
                        promisedActiveDuration: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                longIdleTimeSupport: true;
            };
        }, {
            component: false;
            flags: {
                checkInProtocolSupport: false;
                longIdleTimeSupport: true;
            };
        }, {
            component: false;
            flags: {
                longIdleTimeSupport: true;
                userActiveModeTrigger: false;
            };
        }];
        features: {
            checkInProtocolSupport: BitFlag;
            longIdleTimeSupport: BitFlag;
            userActiveModeTrigger: BitFlag;
        };
        id: 70;
        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<{
    activeModeDuration: FixedAttribute<number, any>;
    activeModeThreshold: FixedAttribute<number, any>;
    idleModeDuration: FixedAttribute<number, any>;
    userActiveModeTriggerInstruction: OptionalFixedAttribute<string, any>;
}, GlobalAttributes<{
    checkInProtocolSupport: BitFlag;
    longIdleTimeSupport: BitFlag;
    userActiveModeTrigger: BitFlag;
}>>

Type declaration

  • ReadonlyactiveModeDuration: FixedAttribute<number, any>

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

    See

    MatterSpecification.v13.Core § 9.17.6.2

  • ReadonlyactiveModeThreshold: FixedAttribute<number, any>

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

    See

    MatterSpecification.v13.Core § 9.17.6.3

  • ReadonlyidleModeDuration: FixedAttribute<number, any>

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

    See

    MatterSpecification.v13.Core § 9.17.6.1

  • ReadonlyuserActiveModeTriggerInstruction: OptionalFixedAttribute<string, any>

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

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

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

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

    When the UserActiveModeTriggerHint key indicates a light to blink (ActuateSensorLightsBlink,

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

    See

    MatterSpecification.v13.Core § 9.17.6.8

base

base: undefined

commands

commands: {
    stayActiveRequest: OptionalCommand<TypeFromFields<{
        stayActiveDuration: FieldType<number>;
    }>, TypeFromFields<{
        promisedActiveDuration: FieldType<number>;
    }>, any>;
}

Type declaration

  • ReadonlystayActiveRequest: OptionalCommand<TypeFromFields<{
        stayActiveDuration: FieldType<number>;
    }>, TypeFromFields<{
        promisedActiveDuration: FieldType<number>;
    }>, any>

    This command allows a client to request that the server stays in active mode for at least a given time duration (in milliseconds) from when this command is received.

    This StayActiveDuration may be longer than the ActiveModeThreshold value and would, typically, be used by the client to request the server to stay active and responsive for this period to allow a sequence of message exchanges during that period. The client may slightly overestimate the duration it wants the ICD to be active for, in order to account for network delays.

    See

    MatterSpecification.v13.Core § 9.17.7.4

events

events: {}

extensions

extensions: readonly [{
    component: {
        attributes: {
            clientsSupportedPerFabric: FixedAttribute<number, any>;
            icdCounter: Attribute<number, any>;
            registeredClients: FabricScopedAttribute<TypeFromFields<{
                checkInNodeId: FieldType<NodeId>;
                fabricIndex: FieldType<FabricIndex>;
                monitoredSubject: FieldType<NodeId>;
            }>[], any>;
        };
        commands: {
            registerClient: Command<TypeFromFields<{
                checkInNodeId: FieldType<NodeId>;
                key: FieldType<Uint8Array>;
                monitoredSubject: FieldType<NodeId>;
                verificationKey: OptionalFieldType<Uint8Array>;
            }>, TypeFromFields<{
                icdCounter: FieldType<number>;
            }>, any>;
            unregisterClient: Command<TypeFromFields<{
                checkInNodeId: FieldType<NodeId>;
                verificationKey: OptionalFieldType<Uint8Array>;
            }>, void, any>;
        };
    };
    flags: {
        checkInProtocolSupport: true;
    };
}, {
    component: {
        attributes: {
            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>;
        };
    };
    flags: {
        userActiveModeTrigger: true;
    };
}, {
    component: {
        attributes: {
            operatingMode: Attribute<IcdManagement.OperatingMode, any>;
        };
        commands: {
            stayActiveRequest: Command<TypeFromFields<{
                stayActiveDuration: FieldType<number>;
            }>, TypeFromFields<{
                promisedActiveDuration: FieldType<number>;
            }>, any>;
        };
    };
    flags: {
        longIdleTimeSupport: true;
    };
}, {
    component: false;
    flags: {
        checkInProtocolSupport: false;
        longIdleTimeSupport: true;
    };
}, {
    component: false;
    flags: {
        longIdleTimeSupport: true;
        userActiveModeTrigger: false;
    };
}]

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<70, "ClusterId">

name

name

revision

revision

supportedFeatures

supportedFeatures: {}

unknown

unknown

Methods

alter

  • alter<const AlterationsT>(alterations): WithAlterations<Of<{
        attributes: {
            activeModeDuration: FixedAttribute<number, any>;
            activeModeThreshold: FixedAttribute<number, any>;
            idleModeDuration: FixedAttribute<number, any>;
            userActiveModeTriggerInstruction: OptionalFixedAttribute<string, any>;
        };
        commands: {
            stayActiveRequest: OptionalCommand<TypeFromFields<{
                stayActiveDuration: FieldType<number>;
            }>, TypeFromFields<{
                promisedActiveDuration: FieldType<number>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    clientsSupportedPerFabric: FixedAttribute<number, any>;
                    icdCounter: Attribute<number, any>;
                    registeredClients: FabricScopedAttribute<TypeFromFields<{
                        checkInNodeId: ...;
                        fabricIndex: ...;
                        monitoredSubject: ...;
                    }>[], any>;
                };
                commands: {
                    registerClient: Command<TypeFromFields<{
                        checkInNodeId: FieldType<(...)>;
                        key: FieldType<(...)>;
                        monitoredSubject: FieldType<(...)>;
                        verificationKey: OptionalFieldType<(...)>;
                    }>, TypeFromFields<{
                        icdCounter: FieldType<(...)>;
                    }>, any>;
                    unregisterClient: Command<TypeFromFields<{
                        checkInNodeId: FieldType<(...)>;
                        verificationKey: OptionalFieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                checkInProtocolSupport: true;
            };
        }, {
            component: {
                attributes: {
                    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>;
                };
            };
            flags: {
                userActiveModeTrigger: true;
            };
        }, {
            component: {
                attributes: {
                    operatingMode: Attribute<IcdManagement.OperatingMode, any>;
                };
                commands: {
                    stayActiveRequest: Command<TypeFromFields<{
                        stayActiveDuration: FieldType<(...)>;
                    }>, TypeFromFields<{
                        promisedActiveDuration: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                longIdleTimeSupport: true;
            };
        }, {
            component: false;
            flags: {
                checkInProtocolSupport: false;
                longIdleTimeSupport: true;
            };
        }, {
            component: false;
            flags: {
                longIdleTimeSupport: true;
                userActiveModeTrigger: false;
            };
        }];
        features: {
            checkInProtocolSupport: BitFlag;
            longIdleTimeSupport: BitFlag;
            userActiveModeTrigger: BitFlag;
        };
        id: 70;
        name: "IcdManagement";
        revision: 2;
    }>, AlterationsT>

  • Modify elements using ElementModifier.alter.

    Type Parameters

    • const AlterationsT extends Alterations<Of<{
          attributes: {
              activeModeDuration: FixedAttribute<number, any>;
              activeModeThreshold: FixedAttribute<number, any>;
              idleModeDuration: FixedAttribute<number, any>;
              userActiveModeTriggerInstruction: OptionalFixedAttribute<string, any>;
          };
          commands: {
              stayActiveRequest: OptionalCommand<TypeFromFields<{
                  stayActiveDuration: FieldType<number>;
              }>, TypeFromFields<{
                  promisedActiveDuration: FieldType<number>;
              }>, any>;
          };
          extensions: readonly [{
              component: {
                  attributes: {
                      clientsSupportedPerFabric: FixedAttribute<number, any>;
                      icdCounter: Attribute<number, any>;
                      registeredClients: FabricScopedAttribute<TypeFromFields<{
                          checkInNodeId: ...;
                          fabricIndex: ...;
                          monitoredSubject: ...;
                      }>[], any>;
                  };
                  commands: {
                      registerClient: Command<TypeFromFields<{
                          checkInNodeId: FieldType<(...)>;
                          key: FieldType<(...)>;
                          monitoredSubject: FieldType<(...)>;
                          verificationKey: OptionalFieldType<(...)>;
                      }>, TypeFromFields<{
                          icdCounter: FieldType<(...)>;
                      }>, any>;
                      unregisterClient: Command<TypeFromFields<{
                          checkInNodeId: FieldType<(...)>;
                          verificationKey: OptionalFieldType<(...)>;
                      }>, void, any>;
                  };
              };
              flags: {
                  checkInProtocolSupport: true;
              };
          }, {
              component: {
                  attributes: {
                      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>;
                  };
              };
              flags: {
                  userActiveModeTrigger: true;
              };
          }, {
              component: {
                  attributes: {
                      operatingMode: Attribute<IcdManagement.OperatingMode, any>;
                  };
                  commands: {
                      stayActiveRequest: Command<TypeFromFields<{
                          stayActiveDuration: FieldType<(...)>;
                      }>, TypeFromFields<{
                          promisedActiveDuration: FieldType<(...)>;
                      }>, any>;
                  };
              };
              flags: {
                  longIdleTimeSupport: true;
              };
          }, {
              component: false;
              flags: {
                  checkInProtocolSupport: false;
                  longIdleTimeSupport: true;
              };
          }, {
              component: false;
              flags: {
                  longIdleTimeSupport: true;
                  userActiveModeTrigger: false;
              };
          }];
          features: {
              checkInProtocolSupport: BitFlag;
              longIdleTimeSupport: BitFlag;
              userActiveModeTrigger: BitFlag;
          };
          id: 70;
          name: "IcdManagement";
          revision: 2;
      }>>

    Parameters

    Returns WithAlterations<Of<{
        attributes: {
            activeModeDuration: FixedAttribute<number, any>;
            activeModeThreshold: FixedAttribute<number, any>;
            idleModeDuration: FixedAttribute<number, any>;
            userActiveModeTriggerInstruction: OptionalFixedAttribute<string, any>;
        };
        commands: {
            stayActiveRequest: OptionalCommand<TypeFromFields<{
                stayActiveDuration: FieldType<number>;
            }>, TypeFromFields<{
                promisedActiveDuration: FieldType<number>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    clientsSupportedPerFabric: FixedAttribute<number, any>;
                    icdCounter: Attribute<number, any>;
                    registeredClients: FabricScopedAttribute<TypeFromFields<{
                        checkInNodeId: ...;
                        fabricIndex: ...;
                        monitoredSubject: ...;
                    }>[], any>;
                };
                commands: {
                    registerClient: Command<TypeFromFields<{
                        checkInNodeId: FieldType<(...)>;
                        key: FieldType<(...)>;
                        monitoredSubject: FieldType<(...)>;
                        verificationKey: OptionalFieldType<(...)>;
                    }>, TypeFromFields<{
                        icdCounter: FieldType<(...)>;
                    }>, any>;
                    unregisterClient: Command<TypeFromFields<{
                        checkInNodeId: FieldType<(...)>;
                        verificationKey: OptionalFieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                checkInProtocolSupport: true;
            };
        }, {
            component: {
                attributes: {
                    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>;
                };
            };
            flags: {
                userActiveModeTrigger: true;
            };
        }, {
            component: {
                attributes: {
                    operatingMode: Attribute<IcdManagement.OperatingMode, any>;
                };
                commands: {
                    stayActiveRequest: Command<TypeFromFields<{
                        stayActiveDuration: FieldType<(...)>;
                    }>, TypeFromFields<{
                        promisedActiveDuration: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                longIdleTimeSupport: true;
            };
        }, {
            component: false;
            flags: {
                checkInProtocolSupport: false;
                longIdleTimeSupport: true;
            };
        }, {
            component: false;
            flags: {
                longIdleTimeSupport: true;
                userActiveModeTrigger: false;
            };
        }];
        features: {
            checkInProtocolSupport: BitFlag;
            longIdleTimeSupport: BitFlag;
            userActiveModeTrigger: BitFlag;
        };
        id: 70;
        name: "IcdManagement";
        revision: 2;
    }>, AlterationsT>

enable

  • enable<const FlagsT>(flags): WithFlags<Of<{
        attributes: {
            activeModeDuration: FixedAttribute<number, any>;
            activeModeThreshold: FixedAttribute<number, any>;
            idleModeDuration: FixedAttribute<number, any>;
            userActiveModeTriggerInstruction: OptionalFixedAttribute<string, any>;
        };
        commands: {
            stayActiveRequest: OptionalCommand<TypeFromFields<{
                stayActiveDuration: FieldType<number>;
            }>, TypeFromFields<{
                promisedActiveDuration: FieldType<number>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    clientsSupportedPerFabric: FixedAttribute<number, any>;
                    icdCounter: Attribute<number, any>;
                    registeredClients: FabricScopedAttribute<TypeFromFields<{
                        checkInNodeId: ...;
                        fabricIndex: ...;
                        monitoredSubject: ...;
                    }>[], any>;
                };
                commands: {
                    registerClient: Command<TypeFromFields<{
                        checkInNodeId: FieldType<(...)>;
                        key: FieldType<(...)>;
                        monitoredSubject: FieldType<(...)>;
                        verificationKey: OptionalFieldType<(...)>;
                    }>, TypeFromFields<{
                        icdCounter: FieldType<(...)>;
                    }>, any>;
                    unregisterClient: Command<TypeFromFields<{
                        checkInNodeId: FieldType<(...)>;
                        verificationKey: OptionalFieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                checkInProtocolSupport: true;
            };
        }, {
            component: {
                attributes: {
                    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>;
                };
            };
            flags: {
                userActiveModeTrigger: true;
            };
        }, {
            component: {
                attributes: {
                    operatingMode: Attribute<IcdManagement.OperatingMode, any>;
                };
                commands: {
                    stayActiveRequest: Command<TypeFromFields<{
                        stayActiveDuration: FieldType<(...)>;
                    }>, TypeFromFields<{
                        promisedActiveDuration: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                longIdleTimeSupport: true;
            };
        }, {
            component: false;
            flags: {
                checkInProtocolSupport: false;
                longIdleTimeSupport: true;
            };
        }, {
            component: false;
            flags: {
                longIdleTimeSupport: true;
                userActiveModeTrigger: false;
            };
        }];
        features: {
            checkInProtocolSupport: BitFlag;
            longIdleTimeSupport: BitFlag;
            userActiveModeTrigger: BitFlag;
        };
        id: 70;
        name: "IcdManagement";
        revision: 2;
    }>, FlagsT>

  • Modify elements using ElementModifier.enable.

    Type Parameters

    • const FlagsT extends ElementFlags<Of<{
          attributes: {
              activeModeDuration: FixedAttribute<number, any>;
              activeModeThreshold: FixedAttribute<number, any>;
              idleModeDuration: FixedAttribute<number, any>;
              userActiveModeTriggerInstruction: OptionalFixedAttribute<string, any>;
          };
          commands: {
              stayActiveRequest: OptionalCommand<TypeFromFields<{
                  stayActiveDuration: FieldType<number>;
              }>, TypeFromFields<{
                  promisedActiveDuration: FieldType<number>;
              }>, any>;
          };
          extensions: readonly [{
              component: {
                  attributes: {
                      clientsSupportedPerFabric: FixedAttribute<number, any>;
                      icdCounter: Attribute<number, any>;
                      registeredClients: FabricScopedAttribute<TypeFromFields<{
                          checkInNodeId: ...;
                          fabricIndex: ...;
                          monitoredSubject: ...;
                      }>[], any>;
                  };
                  commands: {
                      registerClient: Command<TypeFromFields<{
                          checkInNodeId: FieldType<(...)>;
                          key: FieldType<(...)>;
                          monitoredSubject: FieldType<(...)>;
                          verificationKey: OptionalFieldType<(...)>;
                      }>, TypeFromFields<{
                          icdCounter: FieldType<(...)>;
                      }>, any>;
                      unregisterClient: Command<TypeFromFields<{
                          checkInNodeId: FieldType<(...)>;
                          verificationKey: OptionalFieldType<(...)>;
                      }>, void, any>;
                  };
              };
              flags: {
                  checkInProtocolSupport: true;
              };
          }, {
              component: {
                  attributes: {
                      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>;
                  };
              };
              flags: {
                  userActiveModeTrigger: true;
              };
          }, {
              component: {
                  attributes: {
                      operatingMode: Attribute<IcdManagement.OperatingMode, any>;
                  };
                  commands: {
                      stayActiveRequest: Command<TypeFromFields<{
                          stayActiveDuration: FieldType<(...)>;
                      }>, TypeFromFields<{
                          promisedActiveDuration: FieldType<(...)>;
                      }>, any>;
                  };
              };
              flags: {
                  longIdleTimeSupport: true;
              };
          }, {
              component: false;
              flags: {
                  checkInProtocolSupport: false;
                  longIdleTimeSupport: true;
              };
          }, {
              component: false;
              flags: {
                  longIdleTimeSupport: true;
                  userActiveModeTrigger: false;
              };
          }];
          features: {
              checkInProtocolSupport: BitFlag;
              longIdleTimeSupport: BitFlag;
              userActiveModeTrigger: BitFlag;
          };
          id: 70;
          name: "IcdManagement";
          revision: 2;
      }>>

    Parameters

    Returns WithFlags<Of<{
        attributes: {
            activeModeDuration: FixedAttribute<number, any>;
            activeModeThreshold: FixedAttribute<number, any>;
            idleModeDuration: FixedAttribute<number, any>;
            userActiveModeTriggerInstruction: OptionalFixedAttribute<string, any>;
        };
        commands: {
            stayActiveRequest: OptionalCommand<TypeFromFields<{
                stayActiveDuration: FieldType<number>;
            }>, TypeFromFields<{
                promisedActiveDuration: FieldType<number>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    clientsSupportedPerFabric: FixedAttribute<number, any>;
                    icdCounter: Attribute<number, any>;
                    registeredClients: FabricScopedAttribute<TypeFromFields<{
                        checkInNodeId: ...;
                        fabricIndex: ...;
                        monitoredSubject: ...;
                    }>[], any>;
                };
                commands: {
                    registerClient: Command<TypeFromFields<{
                        checkInNodeId: FieldType<(...)>;
                        key: FieldType<(...)>;
                        monitoredSubject: FieldType<(...)>;
                        verificationKey: OptionalFieldType<(...)>;
                    }>, TypeFromFields<{
                        icdCounter: FieldType<(...)>;
                    }>, any>;
                    unregisterClient: Command<TypeFromFields<{
                        checkInNodeId: FieldType<(...)>;
                        verificationKey: OptionalFieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                checkInProtocolSupport: true;
            };
        }, {
            component: {
                attributes: {
                    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>;
                };
            };
            flags: {
                userActiveModeTrigger: true;
            };
        }, {
            component: {
                attributes: {
                    operatingMode: Attribute<IcdManagement.OperatingMode, any>;
                };
                commands: {
                    stayActiveRequest: Command<TypeFromFields<{
                        stayActiveDuration: FieldType<(...)>;
                    }>, TypeFromFields<{
                        promisedActiveDuration: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                longIdleTimeSupport: true;
            };
        }, {
            component: false;
            flags: {
                checkInProtocolSupport: false;
                longIdleTimeSupport: true;
            };
        }, {
            component: false;
            flags: {
                longIdleTimeSupport: true;
                userActiveModeTrigger: false;
            };
        }];
        features: {
            checkInProtocolSupport: BitFlag;
            longIdleTimeSupport: BitFlag;
            userActiveModeTrigger: BitFlag;
        };
        id: 70;
        name: "IcdManagement";
        revision: 2;
    }>, FlagsT>

set

  • set<const ValuesT>(values): WithValues<Of<{
        attributes: {
            activeModeDuration: FixedAttribute<number, any>;
            activeModeThreshold: FixedAttribute<number, any>;
            idleModeDuration: FixedAttribute<number, any>;
            userActiveModeTriggerInstruction: OptionalFixedAttribute<string, any>;
        };
        commands: {
            stayActiveRequest: OptionalCommand<TypeFromFields<{
                stayActiveDuration: FieldType<number>;
            }>, TypeFromFields<{
                promisedActiveDuration: FieldType<number>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    clientsSupportedPerFabric: FixedAttribute<number, any>;
                    icdCounter: Attribute<number, any>;
                    registeredClients: FabricScopedAttribute<TypeFromFields<{
                        checkInNodeId: ...;
                        fabricIndex: ...;
                        monitoredSubject: ...;
                    }>[], any>;
                };
                commands: {
                    registerClient: Command<TypeFromFields<{
                        checkInNodeId: FieldType<(...)>;
                        key: FieldType<(...)>;
                        monitoredSubject: FieldType<(...)>;
                        verificationKey: OptionalFieldType<(...)>;
                    }>, TypeFromFields<{
                        icdCounter: FieldType<(...)>;
                    }>, any>;
                    unregisterClient: Command<TypeFromFields<{
                        checkInNodeId: FieldType<(...)>;
                        verificationKey: OptionalFieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                checkInProtocolSupport: true;
            };
        }, {
            component: {
                attributes: {
                    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>;
                };
            };
            flags: {
                userActiveModeTrigger: true;
            };
        }, {
            component: {
                attributes: {
                    operatingMode: Attribute<IcdManagement.OperatingMode, any>;
                };
                commands: {
                    stayActiveRequest: Command<TypeFromFields<{
                        stayActiveDuration: FieldType<(...)>;
                    }>, TypeFromFields<{
                        promisedActiveDuration: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                longIdleTimeSupport: true;
            };
        }, {
            component: false;
            flags: {
                checkInProtocolSupport: false;
                longIdleTimeSupport: true;
            };
        }, {
            component: false;
            flags: {
                longIdleTimeSupport: true;
                userActiveModeTrigger: false;
            };
        }];
        features: {
            checkInProtocolSupport: BitFlag;
            longIdleTimeSupport: BitFlag;
            userActiveModeTrigger: BitFlag;
        };
        id: 70;
        name: "IcdManagement";
        revision: 2;
    }>, ValuesT>

  • Modify elements using ElementModifier.set.

    Type Parameters

    • const ValuesT extends {
          activeModeDuration: number;
          activeModeThreshold: number;
          idleModeDuration: number;
          userActiveModeTriggerInstruction?: string;
      }

    Parameters

    Returns WithValues<Of<{
        attributes: {
            activeModeDuration: FixedAttribute<number, any>;
            activeModeThreshold: FixedAttribute<number, any>;
            idleModeDuration: FixedAttribute<number, any>;
            userActiveModeTriggerInstruction: OptionalFixedAttribute<string, any>;
        };
        commands: {
            stayActiveRequest: OptionalCommand<TypeFromFields<{
                stayActiveDuration: FieldType<number>;
            }>, TypeFromFields<{
                promisedActiveDuration: FieldType<number>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    clientsSupportedPerFabric: FixedAttribute<number, any>;
                    icdCounter: Attribute<number, any>;
                    registeredClients: FabricScopedAttribute<TypeFromFields<{
                        checkInNodeId: ...;
                        fabricIndex: ...;
                        monitoredSubject: ...;
                    }>[], any>;
                };
                commands: {
                    registerClient: Command<TypeFromFields<{
                        checkInNodeId: FieldType<(...)>;
                        key: FieldType<(...)>;
                        monitoredSubject: FieldType<(...)>;
                        verificationKey: OptionalFieldType<(...)>;
                    }>, TypeFromFields<{
                        icdCounter: FieldType<(...)>;
                    }>, any>;
                    unregisterClient: Command<TypeFromFields<{
                        checkInNodeId: FieldType<(...)>;
                        verificationKey: OptionalFieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                checkInProtocolSupport: true;
            };
        }, {
            component: {
                attributes: {
                    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>;
                };
            };
            flags: {
                userActiveModeTrigger: true;
            };
        }, {
            component: {
                attributes: {
                    operatingMode: Attribute<IcdManagement.OperatingMode, any>;
                };
                commands: {
                    stayActiveRequest: Command<TypeFromFields<{
                        stayActiveDuration: FieldType<(...)>;
                    }>, TypeFromFields<{
                        promisedActiveDuration: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                longIdleTimeSupport: true;
            };
        }, {
            component: false;
            flags: {
                checkInProtocolSupport: false;
                longIdleTimeSupport: true;
            };
        }, {
            component: false;
            flags: {
                longIdleTimeSupport: true;
                userActiveModeTrigger: false;
            };
        }];
        features: {
            checkInProtocolSupport: BitFlag;
            longIdleTimeSupport: BitFlag;
            userActiveModeTrigger: BitFlag;
        };
        id: 70;
        name: "IcdManagement";
        revision: 2;
    }>, ValuesT>

with

  • with<const SelectionT>(...selection): Of<Of<{
        attributes: {
            activeModeDuration: FixedAttribute<number, any>;
            activeModeThreshold: FixedAttribute<number, any>;
            idleModeDuration: FixedAttribute<number, any>;
            userActiveModeTriggerInstruction: OptionalFixedAttribute<string, any>;
        };
        commands: {
            stayActiveRequest: OptionalCommand<TypeFromFields<{
                stayActiveDuration: FieldType<number>;
            }>, TypeFromFields<{
                promisedActiveDuration: FieldType<number>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    clientsSupportedPerFabric: FixedAttribute<number, any>;
                    icdCounter: Attribute<number, any>;
                    registeredClients: FabricScopedAttribute<TypeFromFields<{
                        checkInNodeId: ...;
                        fabricIndex: ...;
                        monitoredSubject: ...;
                    }>[], any>;
                };
                commands: {
                    registerClient: Command<TypeFromFields<{
                        checkInNodeId: FieldType<(...)>;
                        key: FieldType<(...)>;
                        monitoredSubject: FieldType<(...)>;
                        verificationKey: OptionalFieldType<(...)>;
                    }>, TypeFromFields<{
                        icdCounter: FieldType<(...)>;
                    }>, any>;
                    unregisterClient: Command<TypeFromFields<{
                        checkInNodeId: FieldType<(...)>;
                        verificationKey: OptionalFieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                checkInProtocolSupport: true;
            };
        }, {
            component: {
                attributes: {
                    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>;
                };
            };
            flags: {
                userActiveModeTrigger: true;
            };
        }, {
            component: {
                attributes: {
                    operatingMode: Attribute<IcdManagement.OperatingMode, any>;
                };
                commands: {
                    stayActiveRequest: Command<TypeFromFields<{
                        stayActiveDuration: FieldType<(...)>;
                    }>, TypeFromFields<{
                        promisedActiveDuration: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                longIdleTimeSupport: true;
            };
        }, {
            component: false;
            flags: {
                checkInProtocolSupport: false;
                longIdleTimeSupport: true;
            };
        }, {
            component: false;
            flags: {
                longIdleTimeSupport: true;
                userActiveModeTrigger: false;
            };
        }];
        features: {
            checkInProtocolSupport: BitFlag;
            longIdleTimeSupport: BitFlag;
            userActiveModeTrigger: BitFlag;
        };
        id: 70;
        name: "IcdManagement";
        revision: 2;
    }>, SelectionT>

  • Select features using ClusterComposer.compose.

    Type Parameters

    • const SelectionT extends FeatureSelection<Of<{
          attributes: {
              activeModeDuration: FixedAttribute<number, any>;
              activeModeThreshold: FixedAttribute<number, any>;
              idleModeDuration: FixedAttribute<number, any>;
              userActiveModeTriggerInstruction: OptionalFixedAttribute<string, any>;
          };
          commands: {
              stayActiveRequest: OptionalCommand<TypeFromFields<{
                  stayActiveDuration: FieldType<number>;
              }>, TypeFromFields<{
                  promisedActiveDuration: FieldType<number>;
              }>, any>;
          };
          extensions: readonly [{
              component: {
                  attributes: {
                      clientsSupportedPerFabric: FixedAttribute<number, any>;
                      icdCounter: Attribute<number, any>;
                      registeredClients: FabricScopedAttribute<TypeFromFields<{
                          checkInNodeId: ...;
                          fabricIndex: ...;
                          monitoredSubject: ...;
                      }>[], any>;
                  };
                  commands: {
                      registerClient: Command<TypeFromFields<{
                          checkInNodeId: FieldType<(...)>;
                          key: FieldType<(...)>;
                          monitoredSubject: FieldType<(...)>;
                          verificationKey: OptionalFieldType<(...)>;
                      }>, TypeFromFields<{
                          icdCounter: FieldType<(...)>;
                      }>, any>;
                      unregisterClient: Command<TypeFromFields<{
                          checkInNodeId: FieldType<(...)>;
                          verificationKey: OptionalFieldType<(...)>;
                      }>, void, any>;
                  };
              };
              flags: {
                  checkInProtocolSupport: true;
              };
          }, {
              component: {
                  attributes: {
                      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>;
                  };
              };
              flags: {
                  userActiveModeTrigger: true;
              };
          }, {
              component: {
                  attributes: {
                      operatingMode: Attribute<IcdManagement.OperatingMode, any>;
                  };
                  commands: {
                      stayActiveRequest: Command<TypeFromFields<{
                          stayActiveDuration: FieldType<(...)>;
                      }>, TypeFromFields<{
                          promisedActiveDuration: FieldType<(...)>;
                      }>, any>;
                  };
              };
              flags: {
                  longIdleTimeSupport: true;
              };
          }, {
              component: false;
              flags: {
                  checkInProtocolSupport: false;
                  longIdleTimeSupport: true;
              };
          }, {
              component: false;
              flags: {
                  longIdleTimeSupport: true;
                  userActiveModeTrigger: false;
              };
          }];
          features: {
              checkInProtocolSupport: BitFlag;
              longIdleTimeSupport: BitFlag;
              userActiveModeTrigger: BitFlag;
          };
          id: 70;
          name: "IcdManagement";
          revision: 2;
      }>>

    Parameters

    Returns Of<Of<{
        attributes: {
            activeModeDuration: FixedAttribute<number, any>;
            activeModeThreshold: FixedAttribute<number, any>;
            idleModeDuration: FixedAttribute<number, any>;
            userActiveModeTriggerInstruction: OptionalFixedAttribute<string, any>;
        };
        commands: {
            stayActiveRequest: OptionalCommand<TypeFromFields<{
                stayActiveDuration: FieldType<number>;
            }>, TypeFromFields<{
                promisedActiveDuration: FieldType<number>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    clientsSupportedPerFabric: FixedAttribute<number, any>;
                    icdCounter: Attribute<number, any>;
                    registeredClients: FabricScopedAttribute<TypeFromFields<{
                        checkInNodeId: ...;
                        fabricIndex: ...;
                        monitoredSubject: ...;
                    }>[], any>;
                };
                commands: {
                    registerClient: Command<TypeFromFields<{
                        checkInNodeId: FieldType<(...)>;
                        key: FieldType<(...)>;
                        monitoredSubject: FieldType<(...)>;
                        verificationKey: OptionalFieldType<(...)>;
                    }>, TypeFromFields<{
                        icdCounter: FieldType<(...)>;
                    }>, any>;
                    unregisterClient: Command<TypeFromFields<{
                        checkInNodeId: FieldType<(...)>;
                        verificationKey: OptionalFieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                checkInProtocolSupport: true;
            };
        }, {
            component: {
                attributes: {
                    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>;
                };
            };
            flags: {
                userActiveModeTrigger: true;
            };
        }, {
            component: {
                attributes: {
                    operatingMode: Attribute<IcdManagement.OperatingMode, any>;
                };
                commands: {
                    stayActiveRequest: Command<TypeFromFields<{
                        stayActiveDuration: FieldType<(...)>;
                    }>, TypeFromFields<{
                        promisedActiveDuration: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                longIdleTimeSupport: true;
            };
        }, {
            component: false;
            flags: {
                checkInProtocolSupport: false;
                longIdleTimeSupport: true;
            };
        }, {
            component: false;
            flags: {
                longIdleTimeSupport: true;
                userActiveModeTrigger: false;
            };
        }];
        features: {
            checkInProtocolSupport: BitFlag;
            longIdleTimeSupport: BitFlag;
            userActiveModeTrigger: BitFlag;
        };
        id: 70;
        name: "IcdManagement";
        revision: 2;
    }>, SelectionT>

Settings

Member Visibility

On This Page

Properties
Methods