Interface Cluster

Attributes and commands for turning devices on and off.

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

See

MatterSpecification.v13.Cluster § 1.5

interface Cluster {
    attributes: Pick<Merge<{
        onOff: Attribute<boolean, any>;
    }, GlobalAttributes<{
        deadFrontBehavior: BitFlag;
        lighting: BitFlag;
        offOnly: BitFlag;
    }>>,
        | "clusterRevision"
        | "featureMap"
        | "attributeList"
        | "acceptedCommandList"
        | "generatedCommandList"
        | "onOff"> & Omit<unknown, "onOff" | (keyof GlobalAttributes<{ readonly lighting: BitFlag; readonly deadFrontBehavior: BitFlag; readonly offOnly: BitFlag; }>)> & Omit<Merge<{
        onOff: Attribute<boolean, any>;
    }, GlobalAttributes<{
        deadFrontBehavior: BitFlag;
        lighting: BitFlag;
        offOnly: BitFlag;
    }>>, "onOff" | (keyof GlobalAttributes<{ readonly lighting: BitFlag; readonly deadFrontBehavior: BitFlag; readonly offOnly: BitFlag; }>)>;
    base: Of<{
        attributes: {
            onOff: Attribute<boolean, any>;
        };
        commands: {
            off: Command<void, void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    globalSceneControl: Attribute<boolean, any>;
                    offWaitTime: WritableAttribute<number, any>;
                    onTime: WritableAttribute<number, any>;
                    startUpOnOff: WritableAttribute<null | OnOff.StartUpOnOff, any>;
                };
                commands: {
                    offWithEffect: Command<TypeFromFields<{
                        effectIdentifier: FieldType<OnOff.EffectIdentifier>;
                        effectVariant: FieldType<number>;
                    }>, void, any>;
                    onWithRecallGlobalScene: Command<void, void, any>;
                    onWithTimedOff: Command<TypeFromFields<{
                        offWaitTime: FieldType<number>;
                        onOffControl: FieldType<TypeFromPartialBitSchema<(...)>>;
                        onTime: FieldType<number>;
                    }>, void, any>;
                };
            };
            flags: {
                lighting: true;
            };
        }, {
            component: {
                commands: {
                    on: Command<void, void, any>;
                    toggle: Command<void, void, any>;
                };
            };
            flags: {
                offOnly: false;
            };
        }, {
            component: false;
            flags: {
                lighting: true;
                offOnly: true;
            };
        }, {
            component: false;
            flags: {
                deadFrontBehavior: true;
                offOnly: true;
            };
        }, {
            component: false;
            flags: {
                deadFrontBehavior: true;
                lighting: false;
                offOnly: true;
            };
        }];
        features: {
            deadFrontBehavior: BitFlag;
            lighting: BitFlag;
            offOnly: BitFlag;
        };
        id: 6;
        name: "OnOff";
        revision: 6;
    }>;
    commands: Pick<{
        off: Command<void, void, any>;
    }, "off"> & Omit<{
        on: Command<void, void, any>;
        toggle: Command<void, void, any>;
    }, "off"> & Omit<{
        off: Command<void, void, any>;
    }, "on" | "toggle" | "off">;
    events: Pick<{}, never> & Omit<unknown, never> & Omit<{}, never>;
    extensions: readonly [{
        component: {
            attributes: {
                globalSceneControl: Attribute<boolean, any>;
                offWaitTime: WritableAttribute<number, any>;
                onTime: WritableAttribute<number, any>;
                startUpOnOff: WritableAttribute<null | OnOff.StartUpOnOff, any>;
            };
            commands: {
                offWithEffect: Command<TypeFromFields<{
                    effectIdentifier: FieldType<OnOff.EffectIdentifier>;
                    effectVariant: FieldType<number>;
                }>, void, any>;
                onWithRecallGlobalScene: Command<void, void, any>;
                onWithTimedOff: Command<TypeFromFields<{
                    offWaitTime: FieldType<number>;
                    onOffControl: FieldType<TypeFromPartialBitSchema<{
                        acceptOnlyWhenOn: BitFlag;
                    }>>;
                    onTime: FieldType<number>;
                }>, void, any>;
            };
        };
        flags: {
            lighting: true;
        };
    }, {
        component: {
            commands: {
                on: Command<void, void, any>;
                toggle: Command<void, void, any>;
            };
        };
        flags: {
            offOnly: false;
        };
    }, {
        component: false;
        flags: {
            lighting: true;
            offOnly: true;
        };
    }, {
        component: false;
        flags: {
            deadFrontBehavior: true;
            offOnly: true;
        };
    }, {
        component: false;
        flags: {
            deadFrontBehavior: true;
            lighting: false;
            offOnly: true;
        };
    }];
    features: {
        deadFrontBehavior: BitFlag;
        lighting: BitFlag;
        offOnly: BitFlag;
    };
    id: Branded<6, "ClusterId">;
    name: "OnOff";
    revision: 6;
    supportedFeatures: {};
    unknown: false;
    alter<const AlterationsT>(alterations: AlterationsT): WithAlterations<Of<{
        attributes: {
            onOff: Attribute<boolean, any>;
        };
        base: Of<{
            attributes: {
                onOff: Attribute<boolean, any>;
            };
            commands: {
                off: Command<void, void, any>;
            };
            extensions: readonly [{
                component: {
                    attributes: {
                        globalSceneControl: Attribute<boolean, any>;
                        offWaitTime: WritableAttribute<number, any>;
                        onTime: WritableAttribute<number, any>;
                        startUpOnOff: WritableAttribute<(...) | (...), any>;
                    };
                    commands: {
                        offWithEffect: Command<TypeFromFields<(...)>, void, any>;
                        onWithRecallGlobalScene: Command<void, void, any>;
                        onWithTimedOff: Command<TypeFromFields<(...)>, void, any>;
                    };
                };
                flags: {
                    lighting: true;
                };
            }, {
                component: {
                    commands: {
                        on: Command<void, void, any>;
                        toggle: Command<void, void, any>;
                    };
                };
                flags: {
                    offOnly: false;
                };
            }, {
                component: false;
                flags: {
                    lighting: true;
                    offOnly: true;
                };
            }, {
                component: false;
                flags: {
                    deadFrontBehavior: true;
                    offOnly: true;
                };
            }, {
                component: false;
                flags: {
                    deadFrontBehavior: true;
                    lighting: false;
                    offOnly: true;
                };
            }];
            features: {
                deadFrontBehavior: BitFlag;
                lighting: BitFlag;
                offOnly: BitFlag;
            };
            id: 6;
            name: "OnOff";
            revision: 6;
        }>;
        commands: {
            off: Command<void, void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    globalSceneControl: Attribute<boolean, any>;
                    offWaitTime: WritableAttribute<number, any>;
                    onTime: WritableAttribute<number, any>;
                    startUpOnOff: WritableAttribute<null | OnOff.StartUpOnOff, any>;
                };
                commands: {
                    offWithEffect: Command<TypeFromFields<{
                        effectIdentifier: FieldType<(...)>;
                        effectVariant: FieldType<(...)>;
                    }>, void, any>;
                    onWithRecallGlobalScene: Command<void, void, any>;
                    onWithTimedOff: Command<TypeFromFields<{
                        offWaitTime: FieldType<(...)>;
                        onOffControl: FieldType<(...)>;
                        onTime: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                lighting: true;
            };
        }, {
            component: {
                commands: {
                    on: Command<void, void, any>;
                    toggle: Command<void, void, any>;
                };
            };
            flags: {
                offOnly: false;
            };
        }, {
            component: false;
            flags: {
                lighting: true;
                offOnly: true;
            };
        }, {
            component: false;
            flags: {
                deadFrontBehavior: true;
                offOnly: true;
            };
        }, {
            component: false;
            flags: {
                deadFrontBehavior: true;
                lighting: false;
                offOnly: true;
            };
        }];
        features: {
            deadFrontBehavior: BitFlag;
            lighting: BitFlag;
            offOnly: BitFlag;
        };
        id: 6;
        name: "OnOff";
        revision: 6;
    }>, AlterationsT>;
    enable<const FlagsT>(flags: FlagsT): WithFlags<Of<{
        attributes: {
            onOff: Attribute<boolean, any>;
        };
        base: Of<{
            attributes: {
                onOff: Attribute<boolean, any>;
            };
            commands: {
                off: Command<void, void, any>;
            };
            extensions: readonly [{
                component: {
                    attributes: {
                        globalSceneControl: Attribute<boolean, any>;
                        offWaitTime: WritableAttribute<number, any>;
                        onTime: WritableAttribute<number, any>;
                        startUpOnOff: WritableAttribute<(...) | (...), any>;
                    };
                    commands: {
                        offWithEffect: Command<TypeFromFields<(...)>, void, any>;
                        onWithRecallGlobalScene: Command<void, void, any>;
                        onWithTimedOff: Command<TypeFromFields<(...)>, void, any>;
                    };
                };
                flags: {
                    lighting: true;
                };
            }, {
                component: {
                    commands: {
                        on: Command<void, void, any>;
                        toggle: Command<void, void, any>;
                    };
                };
                flags: {
                    offOnly: false;
                };
            }, {
                component: false;
                flags: {
                    lighting: true;
                    offOnly: true;
                };
            }, {
                component: false;
                flags: {
                    deadFrontBehavior: true;
                    offOnly: true;
                };
            }, {
                component: false;
                flags: {
                    deadFrontBehavior: true;
                    lighting: false;
                    offOnly: true;
                };
            }];
            features: {
                deadFrontBehavior: BitFlag;
                lighting: BitFlag;
                offOnly: BitFlag;
            };
            id: 6;
            name: "OnOff";
            revision: 6;
        }>;
        commands: {
            off: Command<void, void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    globalSceneControl: Attribute<boolean, any>;
                    offWaitTime: WritableAttribute<number, any>;
                    onTime: WritableAttribute<number, any>;
                    startUpOnOff: WritableAttribute<null | OnOff.StartUpOnOff, any>;
                };
                commands: {
                    offWithEffect: Command<TypeFromFields<{
                        effectIdentifier: FieldType<(...)>;
                        effectVariant: FieldType<(...)>;
                    }>, void, any>;
                    onWithRecallGlobalScene: Command<void, void, any>;
                    onWithTimedOff: Command<TypeFromFields<{
                        offWaitTime: FieldType<(...)>;
                        onOffControl: FieldType<(...)>;
                        onTime: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                lighting: true;
            };
        }, {
            component: {
                commands: {
                    on: Command<void, void, any>;
                    toggle: Command<void, void, any>;
                };
            };
            flags: {
                offOnly: false;
            };
        }, {
            component: false;
            flags: {
                lighting: true;
                offOnly: true;
            };
        }, {
            component: false;
            flags: {
                deadFrontBehavior: true;
                offOnly: true;
            };
        }, {
            component: false;
            flags: {
                deadFrontBehavior: true;
                lighting: false;
                offOnly: true;
            };
        }];
        features: {
            deadFrontBehavior: BitFlag;
            lighting: BitFlag;
            offOnly: BitFlag;
        };
        id: 6;
        name: "OnOff";
        revision: 6;
    }>, FlagsT>;
    set<const ValuesT>(values: ValuesT): WithValues<Of<{
        attributes: {
            onOff: Attribute<boolean, any>;
        };
        base: Of<{
            attributes: {
                onOff: Attribute<boolean, any>;
            };
            commands: {
                off: Command<void, void, any>;
            };
            extensions: readonly [{
                component: {
                    attributes: {
                        globalSceneControl: Attribute<boolean, any>;
                        offWaitTime: WritableAttribute<number, any>;
                        onTime: WritableAttribute<number, any>;
                        startUpOnOff: WritableAttribute<(...) | (...), any>;
                    };
                    commands: {
                        offWithEffect: Command<TypeFromFields<(...)>, void, any>;
                        onWithRecallGlobalScene: Command<void, void, any>;
                        onWithTimedOff: Command<TypeFromFields<(...)>, void, any>;
                    };
                };
                flags: {
                    lighting: true;
                };
            }, {
                component: {
                    commands: {
                        on: Command<void, void, any>;
                        toggle: Command<void, void, any>;
                    };
                };
                flags: {
                    offOnly: false;
                };
            }, {
                component: false;
                flags: {
                    lighting: true;
                    offOnly: true;
                };
            }, {
                component: false;
                flags: {
                    deadFrontBehavior: true;
                    offOnly: true;
                };
            }, {
                component: false;
                flags: {
                    deadFrontBehavior: true;
                    lighting: false;
                    offOnly: true;
                };
            }];
            features: {
                deadFrontBehavior: BitFlag;
                lighting: BitFlag;
                offOnly: BitFlag;
            };
            id: 6;
            name: "OnOff";
            revision: 6;
        }>;
        commands: {
            off: Command<void, void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    globalSceneControl: Attribute<boolean, any>;
                    offWaitTime: WritableAttribute<number, any>;
                    onTime: WritableAttribute<number, any>;
                    startUpOnOff: WritableAttribute<null | OnOff.StartUpOnOff, any>;
                };
                commands: {
                    offWithEffect: Command<TypeFromFields<{
                        effectIdentifier: FieldType<(...)>;
                        effectVariant: FieldType<(...)>;
                    }>, void, any>;
                    onWithRecallGlobalScene: Command<void, void, any>;
                    onWithTimedOff: Command<TypeFromFields<{
                        offWaitTime: FieldType<(...)>;
                        onOffControl: FieldType<(...)>;
                        onTime: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                lighting: true;
            };
        }, {
            component: {
                commands: {
                    on: Command<void, void, any>;
                    toggle: Command<void, void, any>;
                };
            };
            flags: {
                offOnly: false;
            };
        }, {
            component: false;
            flags: {
                lighting: true;
                offOnly: true;
            };
        }, {
            component: false;
            flags: {
                deadFrontBehavior: true;
                offOnly: true;
            };
        }, {
            component: false;
            flags: {
                deadFrontBehavior: true;
                lighting: false;
                offOnly: true;
            };
        }];
        features: {
            deadFrontBehavior: BitFlag;
            lighting: BitFlag;
            offOnly: BitFlag;
        };
        id: 6;
        name: "OnOff";
        revision: 6;
    }>, ValuesT>;
    with<const SelectionT>(...selection: SelectionT): Of<Of<{
        attributes: {
            onOff: Attribute<boolean, any>;
        };
        base: Of<{
            attributes: {
                onOff: Attribute<boolean, any>;
            };
            commands: {
                off: Command<void, void, any>;
            };
            extensions: readonly [{
                component: {
                    attributes: {
                        globalSceneControl: Attribute<boolean, any>;
                        offWaitTime: WritableAttribute<number, any>;
                        onTime: WritableAttribute<number, any>;
                        startUpOnOff: WritableAttribute<(...) | (...), any>;
                    };
                    commands: {
                        offWithEffect: Command<TypeFromFields<(...)>, void, any>;
                        onWithRecallGlobalScene: Command<void, void, any>;
                        onWithTimedOff: Command<TypeFromFields<(...)>, void, any>;
                    };
                };
                flags: {
                    lighting: true;
                };
            }, {
                component: {
                    commands: {
                        on: Command<void, void, any>;
                        toggle: Command<void, void, any>;
                    };
                };
                flags: {
                    offOnly: false;
                };
            }, {
                component: false;
                flags: {
                    lighting: true;
                    offOnly: true;
                };
            }, {
                component: false;
                flags: {
                    deadFrontBehavior: true;
                    offOnly: true;
                };
            }, {
                component: false;
                flags: {
                    deadFrontBehavior: true;
                    lighting: false;
                    offOnly: true;
                };
            }];
            features: {
                deadFrontBehavior: BitFlag;
                lighting: BitFlag;
                offOnly: BitFlag;
            };
            id: 6;
            name: "OnOff";
            revision: 6;
        }>;
        commands: {
            off: Command<void, void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    globalSceneControl: Attribute<boolean, any>;
                    offWaitTime: WritableAttribute<number, any>;
                    onTime: WritableAttribute<number, any>;
                    startUpOnOff: WritableAttribute<null | OnOff.StartUpOnOff, any>;
                };
                commands: {
                    offWithEffect: Command<TypeFromFields<{
                        effectIdentifier: FieldType<(...)>;
                        effectVariant: FieldType<(...)>;
                    }>, void, any>;
                    onWithRecallGlobalScene: Command<void, void, any>;
                    onWithTimedOff: Command<TypeFromFields<{
                        offWaitTime: FieldType<(...)>;
                        onOffControl: FieldType<(...)>;
                        onTime: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                lighting: true;
            };
        }, {
            component: {
                commands: {
                    on: Command<void, void, any>;
                    toggle: Command<void, void, any>;
                };
            };
            flags: {
                offOnly: false;
            };
        }, {
            component: false;
            flags: {
                lighting: true;
                offOnly: true;
            };
        }, {
            component: false;
            flags: {
                deadFrontBehavior: true;
                offOnly: true;
            };
        }, {
            component: false;
            flags: {
                deadFrontBehavior: true;
                lighting: false;
                offOnly: true;
            };
        }];
        features: {
            deadFrontBehavior: BitFlag;
            lighting: BitFlag;
            offOnly: BitFlag;
        };
        id: 6;
        name: "OnOff";
        revision: 6;
    }>, SelectionT>;
}

Hierarchy (view full)

Properties

attributes base commands events extensions features id name revision supportedFeatures unknown

Methods

alter enable set with

Properties

attributes

attributes: Pick<Merge<{
    onOff: Attribute<boolean, any>;
}, GlobalAttributes<{
    deadFrontBehavior: BitFlag;
    lighting: BitFlag;
    offOnly: BitFlag;
}>>,
    | "clusterRevision"
    | "featureMap"
    | "attributeList"
    | "acceptedCommandList"
    | "generatedCommandList"
    | "onOff"> & Omit<unknown, "onOff" | (keyof GlobalAttributes<{ readonly lighting: BitFlag; readonly deadFrontBehavior: BitFlag; readonly offOnly: BitFlag; }>)> & Omit<Merge<{
    onOff: Attribute<boolean, any>;
}, GlobalAttributes<{
    deadFrontBehavior: BitFlag;
    lighting: BitFlag;
    offOnly: BitFlag;
}>>, "onOff" | (keyof GlobalAttributes<{ readonly lighting: BitFlag; readonly deadFrontBehavior: BitFlag; readonly offOnly: BitFlag; }>)>

base

base: Of<{
    attributes: {
        onOff: Attribute<boolean, any>;
    };
    commands: {
        off: Command<void, void, any>;
    };
    extensions: readonly [{
        component: {
            attributes: {
                globalSceneControl: Attribute<boolean, any>;
                offWaitTime: WritableAttribute<number, any>;
                onTime: WritableAttribute<number, any>;
                startUpOnOff: WritableAttribute<null | OnOff.StartUpOnOff, any>;
            };
            commands: {
                offWithEffect: Command<TypeFromFields<{
                    effectIdentifier: FieldType<OnOff.EffectIdentifier>;
                    effectVariant: FieldType<number>;
                }>, void, any>;
                onWithRecallGlobalScene: Command<void, void, any>;
                onWithTimedOff: Command<TypeFromFields<{
                    offWaitTime: FieldType<number>;
                    onOffControl: FieldType<TypeFromPartialBitSchema<(...)>>;
                    onTime: FieldType<number>;
                }>, void, any>;
            };
        };
        flags: {
            lighting: true;
        };
    }, {
        component: {
            commands: {
                on: Command<void, void, any>;
                toggle: Command<void, void, any>;
            };
        };
        flags: {
            offOnly: false;
        };
    }, {
        component: false;
        flags: {
            lighting: true;
            offOnly: true;
        };
    }, {
        component: false;
        flags: {
            deadFrontBehavior: true;
            offOnly: true;
        };
    }, {
        component: false;
        flags: {
            deadFrontBehavior: true;
            lighting: false;
            offOnly: true;
        };
    }];
    features: {
        deadFrontBehavior: BitFlag;
        lighting: BitFlag;
        offOnly: BitFlag;
    };
    id: 6;
    name: "OnOff";
    revision: 6;
}>

Type declaration

  • Readonlyattributes: {
        onOff: Attribute<boolean, any>;
    }
    • ReadonlyonOff: Attribute<boolean, any>

      This attribute indicates whether the device type implemented on the endpoint is turned off or turned on, in these cases the value of the OnOff attribute equals FALSE, or TRUE respectively.

      See

      MatterSpecification.v13.Cluster § 1.5.6.2

  • Readonlycommands: {
        off: Command<void, void, any>;
    }
    • Readonlyoff: Command<void, void, any>

      See

      MatterSpecification.v13.Cluster § 1.5.7.1

  • Readonlyextensions: readonly [{
        component: {
            attributes: {
                globalSceneControl: Attribute<boolean, any>;
                offWaitTime: WritableAttribute<number, any>;
                onTime: WritableAttribute<number, any>;
                startUpOnOff: WritableAttribute<null | OnOff.StartUpOnOff, any>;
            };
            commands: {
                offWithEffect: Command<TypeFromFields<{
                    effectIdentifier: FieldType<OnOff.EffectIdentifier>;
                    effectVariant: FieldType<number>;
                }>, void, any>;
                onWithRecallGlobalScene: Command<void, void, any>;
                onWithTimedOff: Command<TypeFromFields<{
                    offWaitTime: FieldType<number>;
                    onOffControl: FieldType<TypeFromPartialBitSchema<(...)>>;
                    onTime: FieldType<number>;
                }>, void, any>;
            };
        };
        flags: {
            lighting: true;
        };
    }, {
        component: {
            commands: {
                on: Command<void, void, any>;
                toggle: Command<void, void, any>;
            };
        };
        flags: {
            offOnly: false;
        };
    }, {
        component: false;
        flags: {
            lighting: true;
            offOnly: true;
        };
    }, {
        component: false;
        flags: {
            deadFrontBehavior: true;
            offOnly: true;
        };
    }, {
        component: false;
        flags: {
            deadFrontBehavior: true;
            lighting: false;
            offOnly: true;
        };
    }]

    This metadata controls which OnOffCluster elements matter.js activates for specific feature combinations.

  • Readonlyfeatures: {
        deadFrontBehavior: BitFlag;
        lighting: BitFlag;
        offOnly: BitFlag;
    }
    • ReadonlydeadFrontBehavior: BitFlag

      DeadFrontBehavior

      When this feature is supported, the device exposing this server cluster exhibits "dead front" behavior when the "OnOff" attribute is FALSE (Off). This "dead front" behavior includes:

      • clusters other than this cluster that are also exposed may respond with failures to Invoke and Write interactions. Such failure responses when in a "dead front" shall be with an INVALID_IN_STATE status code.

      • clusters other than this cluster may change the values of their attributes to best-effort values, due to the actual values not being defined or available in this state. Device type specifications that require support for the DF feature SHOULD define what these best-effort values are.

      • Report Transactions shall continue to be generated. Such transactions may include best-effort values as noted above.

      • Event generation logic for clusters other than this cluster is unchanged (noting possible use of best-effort attribute values as in the preceding bullets).

      When this feature is supported and the OnOff attribute changes from TRUE to FALSE (e.g. when receiving an Off Command, or due to a manual interaction on the device), it shall start executing this "dead front" behavior.

      When this feature is supported and the OnOff attribute changes from FALSE to TRUE (e.g. when receiving an On Command, or due to a manual interaction on the device), it shall stop executing this "dead front" behavior.

      When this feature is supported, and any change of the "dead front" state leads to changes in attributes of other clusters due to the "dead front" feature, these attribute changes shall NOT be skipped or omitted from the usual processing associated with attribute changes. For example, if an

      attribute changes from value 4 to null on "dead front" behavior due to an Off command being received, this change shall be processed for reporting and subscriptions.

      See

      MatterSpecification.v13.Cluster § 1.5.4.2

    • Readonlylighting: BitFlag

      Lighting

      This cluster is used for a lighting application.

      On receipt of a Level Control cluster command that causes the OnOff attribute to be set to FALSE, the OnTime attribute shall be set to 0.

      On receipt of a Level Control cluster command that causes the OnOff attribute to be set to TRUE, if the value of the OnTime attribute is equal to 0, the server shall set the OffWaitTime attribute to 0.

      See

      MatterSpecification.v13.Cluster § 1.5.4.1

    • ReadonlyoffOnly: BitFlag

      OffOnly

      When this feature is supported, the Off command shall be supported and the On and Toggle commands shall NOT be supported.

      This feature is useful for devices which can be turned off via the Off command received by an instance of this cluster but cannot be turned on via commands received by an instance of this cluster due to regulatory requirements.

      See

      MatterSpecification.v13.Cluster § 1.5.4.3

  • Readonlyid: 6
  • Readonlyname: "OnOff"
  • Readonlyrevision: 6

commands

commands: Pick<{
    off: Command<void, void, any>;
}, "off"> & Omit<{
    on: Command<void, void, any>;
    toggle: Command<void, void, any>;
}, "off"> & Omit<{
    off: Command<void, void, any>;
}, "on" | "toggle" | "off">

events

events: Pick<{}, never> & Omit<unknown, never> & Omit<{}, never>

extensions

extensions: readonly [{
    component: {
        attributes: {
            globalSceneControl: Attribute<boolean, any>;
            offWaitTime: WritableAttribute<number, any>;
            onTime: WritableAttribute<number, any>;
            startUpOnOff: WritableAttribute<null | OnOff.StartUpOnOff, any>;
        };
        commands: {
            offWithEffect: Command<TypeFromFields<{
                effectIdentifier: FieldType<OnOff.EffectIdentifier>;
                effectVariant: FieldType<number>;
            }>, void, any>;
            onWithRecallGlobalScene: Command<void, void, any>;
            onWithTimedOff: Command<TypeFromFields<{
                offWaitTime: FieldType<number>;
                onOffControl: FieldType<TypeFromPartialBitSchema<{
                    acceptOnlyWhenOn: BitFlag;
                }>>;
                onTime: FieldType<number>;
            }>, void, any>;
        };
    };
    flags: {
        lighting: true;
    };
}, {
    component: {
        commands: {
            on: Command<void, void, any>;
            toggle: Command<void, void, any>;
        };
    };
    flags: {
        offOnly: false;
    };
}, {
    component: false;
    flags: {
        lighting: true;
        offOnly: true;
    };
}, {
    component: false;
    flags: {
        deadFrontBehavior: true;
        offOnly: true;
    };
}, {
    component: false;
    flags: {
        deadFrontBehavior: true;
        lighting: false;
        offOnly: true;
    };
}]

features

features: {
    deadFrontBehavior: BitFlag;
    lighting: BitFlag;
    offOnly: BitFlag;
}

Type declaration

  • ReadonlydeadFrontBehavior: BitFlag

    DeadFrontBehavior

    When this feature is supported, the device exposing this server cluster exhibits "dead front" behavior when the "OnOff" attribute is FALSE (Off). This "dead front" behavior includes:

    • clusters other than this cluster that are also exposed may respond with failures to Invoke and Write interactions. Such failure responses when in a "dead front" shall be with an INVALID_IN_STATE status code.

    • clusters other than this cluster may change the values of their attributes to best-effort values, due to the actual values not being defined or available in this state. Device type specifications that require support for the DF feature SHOULD define what these best-effort values are.

    • Report Transactions shall continue to be generated. Such transactions may include best-effort values as noted above.

    • Event generation logic for clusters other than this cluster is unchanged (noting possible use of best-effort attribute values as in the preceding bullets).

    When this feature is supported and the OnOff attribute changes from TRUE to FALSE (e.g. when receiving an Off Command, or due to a manual interaction on the device), it shall start executing this "dead front" behavior.

    When this feature is supported and the OnOff attribute changes from FALSE to TRUE (e.g. when receiving an On Command, or due to a manual interaction on the device), it shall stop executing this "dead front" behavior.

    When this feature is supported, and any change of the "dead front" state leads to changes in attributes of other clusters due to the "dead front" feature, these attribute changes shall NOT be skipped or omitted from the usual processing associated with attribute changes. For example, if an

    attribute changes from value 4 to null on "dead front" behavior due to an Off command being received, this change shall be processed for reporting and subscriptions.

    See

    MatterSpecification.v13.Cluster § 1.5.4.2

  • Readonlylighting: BitFlag

    Lighting

    This cluster is used for a lighting application.

    On receipt of a Level Control cluster command that causes the OnOff attribute to be set to FALSE, the OnTime attribute shall be set to 0.

    On receipt of a Level Control cluster command that causes the OnOff attribute to be set to TRUE, if the value of the OnTime attribute is equal to 0, the server shall set the OffWaitTime attribute to 0.

    See

    MatterSpecification.v13.Cluster § 1.5.4.1

  • ReadonlyoffOnly: BitFlag

    OffOnly

    When this feature is supported, the Off command shall be supported and the On and Toggle commands shall NOT be supported.

    This feature is useful for devices which can be turned off via the Off command received by an instance of this cluster but cannot be turned on via commands received by an instance of this cluster due to regulatory requirements.

    See

    MatterSpecification.v13.Cluster § 1.5.4.3

id

id: Branded<6, "ClusterId">

name

name

revision

revision

supportedFeatures

supportedFeatures: {}

unknown

unknown

Methods

alter

  • alter<const AlterationsT>(alterations): WithAlterations<Of<{
        attributes: {
            onOff: Attribute<boolean, any>;
        };
        base: Of<{
            attributes: {
                onOff: Attribute<boolean, any>;
            };
            commands: {
                off: Command<void, void, any>;
            };
            extensions: readonly [{
                component: {
                    attributes: {
                        globalSceneControl: Attribute<boolean, any>;
                        offWaitTime: WritableAttribute<number, any>;
                        onTime: WritableAttribute<number, any>;
                        startUpOnOff: WritableAttribute<(...) | (...), any>;
                    };
                    commands: {
                        offWithEffect: Command<TypeFromFields<(...)>, void, any>;
                        onWithRecallGlobalScene: Command<void, void, any>;
                        onWithTimedOff: Command<TypeFromFields<(...)>, void, any>;
                    };
                };
                flags: {
                    lighting: true;
                };
            }, {
                component: {
                    commands: {
                        on: Command<void, void, any>;
                        toggle: Command<void, void, any>;
                    };
                };
                flags: {
                    offOnly: false;
                };
            }, {
                component: false;
                flags: {
                    lighting: true;
                    offOnly: true;
                };
            }, {
                component: false;
                flags: {
                    deadFrontBehavior: true;
                    offOnly: true;
                };
            }, {
                component: false;
                flags: {
                    deadFrontBehavior: true;
                    lighting: false;
                    offOnly: true;
                };
            }];
            features: {
                deadFrontBehavior: BitFlag;
                lighting: BitFlag;
                offOnly: BitFlag;
            };
            id: 6;
            name: "OnOff";
            revision: 6;
        }>;
        commands: {
            off: Command<void, void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    globalSceneControl: Attribute<boolean, any>;
                    offWaitTime: WritableAttribute<number, any>;
                    onTime: WritableAttribute<number, any>;
                    startUpOnOff: WritableAttribute<null | OnOff.StartUpOnOff, any>;
                };
                commands: {
                    offWithEffect: Command<TypeFromFields<{
                        effectIdentifier: FieldType<(...)>;
                        effectVariant: FieldType<(...)>;
                    }>, void, any>;
                    onWithRecallGlobalScene: Command<void, void, any>;
                    onWithTimedOff: Command<TypeFromFields<{
                        offWaitTime: FieldType<(...)>;
                        onOffControl: FieldType<(...)>;
                        onTime: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                lighting: true;
            };
        }, {
            component: {
                commands: {
                    on: Command<void, void, any>;
                    toggle: Command<void, void, any>;
                };
            };
            flags: {
                offOnly: false;
            };
        }, {
            component: false;
            flags: {
                lighting: true;
                offOnly: true;
            };
        }, {
            component: false;
            flags: {
                deadFrontBehavior: true;
                offOnly: true;
            };
        }, {
            component: false;
            flags: {
                deadFrontBehavior: true;
                lighting: false;
                offOnly: true;
            };
        }];
        features: {
            deadFrontBehavior: BitFlag;
            lighting: BitFlag;
            offOnly: BitFlag;
        };
        id: 6;
        name: "OnOff";
        revision: 6;
    }>, AlterationsT>

  • Modify elements using ElementModifier.alter.

    Type Parameters

    • const AlterationsT extends Alterations<Of<{
          attributes: {
              onOff: Attribute<boolean, any>;
          };
          base: Of<{
              attributes: {
                  onOff: Attribute<boolean, any>;
              };
              commands: {
                  off: Command<void, void, any>;
              };
              extensions: readonly [{
                  component: {
                      attributes: {
                          globalSceneControl: Attribute<boolean, any>;
                          offWaitTime: WritableAttribute<number, any>;
                          onTime: WritableAttribute<number, any>;
                          startUpOnOff: WritableAttribute<(...) | (...), any>;
                      };
                      commands: {
                          offWithEffect: Command<TypeFromFields<(...)>, void, any>;
                          onWithRecallGlobalScene: Command<void, void, any>;
                          onWithTimedOff: Command<TypeFromFields<(...)>, void, any>;
                      };
                  };
                  flags: {
                      lighting: true;
                  };
              }, {
                  component: {
                      commands: {
                          on: Command<void, void, any>;
                          toggle: Command<void, void, any>;
                      };
                  };
                  flags: {
                      offOnly: false;
                  };
              }, {
                  component: false;
                  flags: {
                      lighting: true;
                      offOnly: true;
                  };
              }, {
                  component: false;
                  flags: {
                      deadFrontBehavior: true;
                      offOnly: true;
                  };
              }, {
                  component: false;
                  flags: {
                      deadFrontBehavior: true;
                      lighting: false;
                      offOnly: true;
                  };
              }];
              features: {
                  deadFrontBehavior: BitFlag;
                  lighting: BitFlag;
                  offOnly: BitFlag;
              };
              id: 6;
              name: "OnOff";
              revision: 6;
          }>;
          commands: {
              off: Command<void, void, any>;
          };
          extensions: readonly [{
              component: {
                  attributes: {
                      globalSceneControl: Attribute<boolean, any>;
                      offWaitTime: WritableAttribute<number, any>;
                      onTime: WritableAttribute<number, any>;
                      startUpOnOff: WritableAttribute<null | OnOff.StartUpOnOff, any>;
                  };
                  commands: {
                      offWithEffect: Command<TypeFromFields<{
                          effectIdentifier: FieldType<(...)>;
                          effectVariant: FieldType<(...)>;
                      }>, void, any>;
                      onWithRecallGlobalScene: Command<void, void, any>;
                      onWithTimedOff: Command<TypeFromFields<{
                          offWaitTime: FieldType<(...)>;
                          onOffControl: FieldType<(...)>;
                          onTime: FieldType<(...)>;
                      }>, void, any>;
                  };
              };
              flags: {
                  lighting: true;
              };
          }, {
              component: {
                  commands: {
                      on: Command<void, void, any>;
                      toggle: Command<void, void, any>;
                  };
              };
              flags: {
                  offOnly: false;
              };
          }, {
              component: false;
              flags: {
                  lighting: true;
                  offOnly: true;
              };
          }, {
              component: false;
              flags: {
                  deadFrontBehavior: true;
                  offOnly: true;
              };
          }, {
              component: false;
              flags: {
                  deadFrontBehavior: true;
                  lighting: false;
                  offOnly: true;
              };
          }];
          features: {
              deadFrontBehavior: BitFlag;
              lighting: BitFlag;
              offOnly: BitFlag;
          };
          id: 6;
          name: "OnOff";
          revision: 6;
      }>>

    Parameters

    Returns WithAlterations<Of<{
        attributes: {
            onOff: Attribute<boolean, any>;
        };
        base: Of<{
            attributes: {
                onOff: Attribute<boolean, any>;
            };
            commands: {
                off: Command<void, void, any>;
            };
            extensions: readonly [{
                component: {
                    attributes: {
                        globalSceneControl: Attribute<boolean, any>;
                        offWaitTime: WritableAttribute<number, any>;
                        onTime: WritableAttribute<number, any>;
                        startUpOnOff: WritableAttribute<(...) | (...), any>;
                    };
                    commands: {
                        offWithEffect: Command<TypeFromFields<(...)>, void, any>;
                        onWithRecallGlobalScene: Command<void, void, any>;
                        onWithTimedOff: Command<TypeFromFields<(...)>, void, any>;
                    };
                };
                flags: {
                    lighting: true;
                };
            }, {
                component: {
                    commands: {
                        on: Command<void, void, any>;
                        toggle: Command<void, void, any>;
                    };
                };
                flags: {
                    offOnly: false;
                };
            }, {
                component: false;
                flags: {
                    lighting: true;
                    offOnly: true;
                };
            }, {
                component: false;
                flags: {
                    deadFrontBehavior: true;
                    offOnly: true;
                };
            }, {
                component: false;
                flags: {
                    deadFrontBehavior: true;
                    lighting: false;
                    offOnly: true;
                };
            }];
            features: {
                deadFrontBehavior: BitFlag;
                lighting: BitFlag;
                offOnly: BitFlag;
            };
            id: 6;
            name: "OnOff";
            revision: 6;
        }>;
        commands: {
            off: Command<void, void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    globalSceneControl: Attribute<boolean, any>;
                    offWaitTime: WritableAttribute<number, any>;
                    onTime: WritableAttribute<number, any>;
                    startUpOnOff: WritableAttribute<null | OnOff.StartUpOnOff, any>;
                };
                commands: {
                    offWithEffect: Command<TypeFromFields<{
                        effectIdentifier: FieldType<(...)>;
                        effectVariant: FieldType<(...)>;
                    }>, void, any>;
                    onWithRecallGlobalScene: Command<void, void, any>;
                    onWithTimedOff: Command<TypeFromFields<{
                        offWaitTime: FieldType<(...)>;
                        onOffControl: FieldType<(...)>;
                        onTime: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                lighting: true;
            };
        }, {
            component: {
                commands: {
                    on: Command<void, void, any>;
                    toggle: Command<void, void, any>;
                };
            };
            flags: {
                offOnly: false;
            };
        }, {
            component: false;
            flags: {
                lighting: true;
                offOnly: true;
            };
        }, {
            component: false;
            flags: {
                deadFrontBehavior: true;
                offOnly: true;
            };
        }, {
            component: false;
            flags: {
                deadFrontBehavior: true;
                lighting: false;
                offOnly: true;
            };
        }];
        features: {
            deadFrontBehavior: BitFlag;
            lighting: BitFlag;
            offOnly: BitFlag;
        };
        id: 6;
        name: "OnOff";
        revision: 6;
    }>, AlterationsT>

enable

  • enable<const FlagsT>(flags): WithFlags<Of<{
        attributes: {
            onOff: Attribute<boolean, any>;
        };
        base: Of<{
            attributes: {
                onOff: Attribute<boolean, any>;
            };
            commands: {
                off: Command<void, void, any>;
            };
            extensions: readonly [{
                component: {
                    attributes: {
                        globalSceneControl: Attribute<boolean, any>;
                        offWaitTime: WritableAttribute<number, any>;
                        onTime: WritableAttribute<number, any>;
                        startUpOnOff: WritableAttribute<(...) | (...), any>;
                    };
                    commands: {
                        offWithEffect: Command<TypeFromFields<(...)>, void, any>;
                        onWithRecallGlobalScene: Command<void, void, any>;
                        onWithTimedOff: Command<TypeFromFields<(...)>, void, any>;
                    };
                };
                flags: {
                    lighting: true;
                };
            }, {
                component: {
                    commands: {
                        on: Command<void, void, any>;
                        toggle: Command<void, void, any>;
                    };
                };
                flags: {
                    offOnly: false;
                };
            }, {
                component: false;
                flags: {
                    lighting: true;
                    offOnly: true;
                };
            }, {
                component: false;
                flags: {
                    deadFrontBehavior: true;
                    offOnly: true;
                };
            }, {
                component: false;
                flags: {
                    deadFrontBehavior: true;
                    lighting: false;
                    offOnly: true;
                };
            }];
            features: {
                deadFrontBehavior: BitFlag;
                lighting: BitFlag;
                offOnly: BitFlag;
            };
            id: 6;
            name: "OnOff";
            revision: 6;
        }>;
        commands: {
            off: Command<void, void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    globalSceneControl: Attribute<boolean, any>;
                    offWaitTime: WritableAttribute<number, any>;
                    onTime: WritableAttribute<number, any>;
                    startUpOnOff: WritableAttribute<null | OnOff.StartUpOnOff, any>;
                };
                commands: {
                    offWithEffect: Command<TypeFromFields<{
                        effectIdentifier: FieldType<(...)>;
                        effectVariant: FieldType<(...)>;
                    }>, void, any>;
                    onWithRecallGlobalScene: Command<void, void, any>;
                    onWithTimedOff: Command<TypeFromFields<{
                        offWaitTime: FieldType<(...)>;
                        onOffControl: FieldType<(...)>;
                        onTime: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                lighting: true;
            };
        }, {
            component: {
                commands: {
                    on: Command<void, void, any>;
                    toggle: Command<void, void, any>;
                };
            };
            flags: {
                offOnly: false;
            };
        }, {
            component: false;
            flags: {
                lighting: true;
                offOnly: true;
            };
        }, {
            component: false;
            flags: {
                deadFrontBehavior: true;
                offOnly: true;
            };
        }, {
            component: false;
            flags: {
                deadFrontBehavior: true;
                lighting: false;
                offOnly: true;
            };
        }];
        features: {
            deadFrontBehavior: BitFlag;
            lighting: BitFlag;
            offOnly: BitFlag;
        };
        id: 6;
        name: "OnOff";
        revision: 6;
    }>, FlagsT>

  • Modify elements using ElementModifier.enable.

    Type Parameters

    • const FlagsT extends ElementFlags<Of<{
          attributes: {
              onOff: Attribute<boolean, any>;
          };
          base: Of<{
              attributes: {
                  onOff: Attribute<boolean, any>;
              };
              commands: {
                  off: Command<void, void, any>;
              };
              extensions: readonly [{
                  component: {
                      attributes: {
                          globalSceneControl: Attribute<boolean, any>;
                          offWaitTime: WritableAttribute<number, any>;
                          onTime: WritableAttribute<number, any>;
                          startUpOnOff: WritableAttribute<(...) | (...), any>;
                      };
                      commands: {
                          offWithEffect: Command<TypeFromFields<(...)>, void, any>;
                          onWithRecallGlobalScene: Command<void, void, any>;
                          onWithTimedOff: Command<TypeFromFields<(...)>, void, any>;
                      };
                  };
                  flags: {
                      lighting: true;
                  };
              }, {
                  component: {
                      commands: {
                          on: Command<void, void, any>;
                          toggle: Command<void, void, any>;
                      };
                  };
                  flags: {
                      offOnly: false;
                  };
              }, {
                  component: false;
                  flags: {
                      lighting: true;
                      offOnly: true;
                  };
              }, {
                  component: false;
                  flags: {
                      deadFrontBehavior: true;
                      offOnly: true;
                  };
              }, {
                  component: false;
                  flags: {
                      deadFrontBehavior: true;
                      lighting: false;
                      offOnly: true;
                  };
              }];
              features: {
                  deadFrontBehavior: BitFlag;
                  lighting: BitFlag;
                  offOnly: BitFlag;
              };
              id: 6;
              name: "OnOff";
              revision: 6;
          }>;
          commands: {
              off: Command<void, void, any>;
          };
          extensions: readonly [{
              component: {
                  attributes: {
                      globalSceneControl: Attribute<boolean, any>;
                      offWaitTime: WritableAttribute<number, any>;
                      onTime: WritableAttribute<number, any>;
                      startUpOnOff: WritableAttribute<null | OnOff.StartUpOnOff, any>;
                  };
                  commands: {
                      offWithEffect: Command<TypeFromFields<{
                          effectIdentifier: FieldType<(...)>;
                          effectVariant: FieldType<(...)>;
                      }>, void, any>;
                      onWithRecallGlobalScene: Command<void, void, any>;
                      onWithTimedOff: Command<TypeFromFields<{
                          offWaitTime: FieldType<(...)>;
                          onOffControl: FieldType<(...)>;
                          onTime: FieldType<(...)>;
                      }>, void, any>;
                  };
              };
              flags: {
                  lighting: true;
              };
          }, {
              component: {
                  commands: {
                      on: Command<void, void, any>;
                      toggle: Command<void, void, any>;
                  };
              };
              flags: {
                  offOnly: false;
              };
          }, {
              component: false;
              flags: {
                  lighting: true;
                  offOnly: true;
              };
          }, {
              component: false;
              flags: {
                  deadFrontBehavior: true;
                  offOnly: true;
              };
          }, {
              component: false;
              flags: {
                  deadFrontBehavior: true;
                  lighting: false;
                  offOnly: true;
              };
          }];
          features: {
              deadFrontBehavior: BitFlag;
              lighting: BitFlag;
              offOnly: BitFlag;
          };
          id: 6;
          name: "OnOff";
          revision: 6;
      }>>

    Parameters

    Returns WithFlags<Of<{
        attributes: {
            onOff: Attribute<boolean, any>;
        };
        base: Of<{
            attributes: {
                onOff: Attribute<boolean, any>;
            };
            commands: {
                off: Command<void, void, any>;
            };
            extensions: readonly [{
                component: {
                    attributes: {
                        globalSceneControl: Attribute<boolean, any>;
                        offWaitTime: WritableAttribute<number, any>;
                        onTime: WritableAttribute<number, any>;
                        startUpOnOff: WritableAttribute<(...) | (...), any>;
                    };
                    commands: {
                        offWithEffect: Command<TypeFromFields<(...)>, void, any>;
                        onWithRecallGlobalScene: Command<void, void, any>;
                        onWithTimedOff: Command<TypeFromFields<(...)>, void, any>;
                    };
                };
                flags: {
                    lighting: true;
                };
            }, {
                component: {
                    commands: {
                        on: Command<void, void, any>;
                        toggle: Command<void, void, any>;
                    };
                };
                flags: {
                    offOnly: false;
                };
            }, {
                component: false;
                flags: {
                    lighting: true;
                    offOnly: true;
                };
            }, {
                component: false;
                flags: {
                    deadFrontBehavior: true;
                    offOnly: true;
                };
            }, {
                component: false;
                flags: {
                    deadFrontBehavior: true;
                    lighting: false;
                    offOnly: true;
                };
            }];
            features: {
                deadFrontBehavior: BitFlag;
                lighting: BitFlag;
                offOnly: BitFlag;
            };
            id: 6;
            name: "OnOff";
            revision: 6;
        }>;
        commands: {
            off: Command<void, void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    globalSceneControl: Attribute<boolean, any>;
                    offWaitTime: WritableAttribute<number, any>;
                    onTime: WritableAttribute<number, any>;
                    startUpOnOff: WritableAttribute<null | OnOff.StartUpOnOff, any>;
                };
                commands: {
                    offWithEffect: Command<TypeFromFields<{
                        effectIdentifier: FieldType<(...)>;
                        effectVariant: FieldType<(...)>;
                    }>, void, any>;
                    onWithRecallGlobalScene: Command<void, void, any>;
                    onWithTimedOff: Command<TypeFromFields<{
                        offWaitTime: FieldType<(...)>;
                        onOffControl: FieldType<(...)>;
                        onTime: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                lighting: true;
            };
        }, {
            component: {
                commands: {
                    on: Command<void, void, any>;
                    toggle: Command<void, void, any>;
                };
            };
            flags: {
                offOnly: false;
            };
        }, {
            component: false;
            flags: {
                lighting: true;
                offOnly: true;
            };
        }, {
            component: false;
            flags: {
                deadFrontBehavior: true;
                offOnly: true;
            };
        }, {
            component: false;
            flags: {
                deadFrontBehavior: true;
                lighting: false;
                offOnly: true;
            };
        }];
        features: {
            deadFrontBehavior: BitFlag;
            lighting: BitFlag;
            offOnly: BitFlag;
        };
        id: 6;
        name: "OnOff";
        revision: 6;
    }>, FlagsT>

set

  • set<const ValuesT>(values): WithValues<Of<{
        attributes: {
            onOff: Attribute<boolean, any>;
        };
        base: Of<{
            attributes: {
                onOff: Attribute<boolean, any>;
            };
            commands: {
                off: Command<void, void, any>;
            };
            extensions: readonly [{
                component: {
                    attributes: {
                        globalSceneControl: Attribute<boolean, any>;
                        offWaitTime: WritableAttribute<number, any>;
                        onTime: WritableAttribute<number, any>;
                        startUpOnOff: WritableAttribute<(...) | (...), any>;
                    };
                    commands: {
                        offWithEffect: Command<TypeFromFields<(...)>, void, any>;
                        onWithRecallGlobalScene: Command<void, void, any>;
                        onWithTimedOff: Command<TypeFromFields<(...)>, void, any>;
                    };
                };
                flags: {
                    lighting: true;
                };
            }, {
                component: {
                    commands: {
                        on: Command<void, void, any>;
                        toggle: Command<void, void, any>;
                    };
                };
                flags: {
                    offOnly: false;
                };
            }, {
                component: false;
                flags: {
                    lighting: true;
                    offOnly: true;
                };
            }, {
                component: false;
                flags: {
                    deadFrontBehavior: true;
                    offOnly: true;
                };
            }, {
                component: false;
                flags: {
                    deadFrontBehavior: true;
                    lighting: false;
                    offOnly: true;
                };
            }];
            features: {
                deadFrontBehavior: BitFlag;
                lighting: BitFlag;
                offOnly: BitFlag;
            };
            id: 6;
            name: "OnOff";
            revision: 6;
        }>;
        commands: {
            off: Command<void, void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    globalSceneControl: Attribute<boolean, any>;
                    offWaitTime: WritableAttribute<number, any>;
                    onTime: WritableAttribute<number, any>;
                    startUpOnOff: WritableAttribute<null | OnOff.StartUpOnOff, any>;
                };
                commands: {
                    offWithEffect: Command<TypeFromFields<{
                        effectIdentifier: FieldType<(...)>;
                        effectVariant: FieldType<(...)>;
                    }>, void, any>;
                    onWithRecallGlobalScene: Command<void, void, any>;
                    onWithTimedOff: Command<TypeFromFields<{
                        offWaitTime: FieldType<(...)>;
                        onOffControl: FieldType<(...)>;
                        onTime: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                lighting: true;
            };
        }, {
            component: {
                commands: {
                    on: Command<void, void, any>;
                    toggle: Command<void, void, any>;
                };
            };
            flags: {
                offOnly: false;
            };
        }, {
            component: false;
            flags: {
                lighting: true;
                offOnly: true;
            };
        }, {
            component: false;
            flags: {
                deadFrontBehavior: true;
                offOnly: true;
            };
        }, {
            component: false;
            flags: {
                deadFrontBehavior: true;
                lighting: false;
                offOnly: true;
            };
        }];
        features: {
            deadFrontBehavior: BitFlag;
            lighting: BitFlag;
            offOnly: BitFlag;
        };
        id: 6;
        name: "OnOff";
        revision: 6;
    }>, ValuesT>

  • Modify elements using ElementModifier.set.

    Type Parameters

    • const ValuesT extends {
          onOff: boolean;
      }

    Parameters

    Returns WithValues<Of<{
        attributes: {
            onOff: Attribute<boolean, any>;
        };
        base: Of<{
            attributes: {
                onOff: Attribute<boolean, any>;
            };
            commands: {
                off: Command<void, void, any>;
            };
            extensions: readonly [{
                component: {
                    attributes: {
                        globalSceneControl: Attribute<boolean, any>;
                        offWaitTime: WritableAttribute<number, any>;
                        onTime: WritableAttribute<number, any>;
                        startUpOnOff: WritableAttribute<(...) | (...), any>;
                    };
                    commands: {
                        offWithEffect: Command<TypeFromFields<(...)>, void, any>;
                        onWithRecallGlobalScene: Command<void, void, any>;
                        onWithTimedOff: Command<TypeFromFields<(...)>, void, any>;
                    };
                };
                flags: {
                    lighting: true;
                };
            }, {
                component: {
                    commands: {
                        on: Command<void, void, any>;
                        toggle: Command<void, void, any>;
                    };
                };
                flags: {
                    offOnly: false;
                };
            }, {
                component: false;
                flags: {
                    lighting: true;
                    offOnly: true;
                };
            }, {
                component: false;
                flags: {
                    deadFrontBehavior: true;
                    offOnly: true;
                };
            }, {
                component: false;
                flags: {
                    deadFrontBehavior: true;
                    lighting: false;
                    offOnly: true;
                };
            }];
            features: {
                deadFrontBehavior: BitFlag;
                lighting: BitFlag;
                offOnly: BitFlag;
            };
            id: 6;
            name: "OnOff";
            revision: 6;
        }>;
        commands: {
            off: Command<void, void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    globalSceneControl: Attribute<boolean, any>;
                    offWaitTime: WritableAttribute<number, any>;
                    onTime: WritableAttribute<number, any>;
                    startUpOnOff: WritableAttribute<null | OnOff.StartUpOnOff, any>;
                };
                commands: {
                    offWithEffect: Command<TypeFromFields<{
                        effectIdentifier: FieldType<(...)>;
                        effectVariant: FieldType<(...)>;
                    }>, void, any>;
                    onWithRecallGlobalScene: Command<void, void, any>;
                    onWithTimedOff: Command<TypeFromFields<{
                        offWaitTime: FieldType<(...)>;
                        onOffControl: FieldType<(...)>;
                        onTime: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                lighting: true;
            };
        }, {
            component: {
                commands: {
                    on: Command<void, void, any>;
                    toggle: Command<void, void, any>;
                };
            };
            flags: {
                offOnly: false;
            };
        }, {
            component: false;
            flags: {
                lighting: true;
                offOnly: true;
            };
        }, {
            component: false;
            flags: {
                deadFrontBehavior: true;
                offOnly: true;
            };
        }, {
            component: false;
            flags: {
                deadFrontBehavior: true;
                lighting: false;
                offOnly: true;
            };
        }];
        features: {
            deadFrontBehavior: BitFlag;
            lighting: BitFlag;
            offOnly: BitFlag;
        };
        id: 6;
        name: "OnOff";
        revision: 6;
    }>, ValuesT>

with

  • with<const SelectionT>(...selection): Of<Of<{
        attributes: {
            onOff: Attribute<boolean, any>;
        };
        base: Of<{
            attributes: {
                onOff: Attribute<boolean, any>;
            };
            commands: {
                off: Command<void, void, any>;
            };
            extensions: readonly [{
                component: {
                    attributes: {
                        globalSceneControl: Attribute<boolean, any>;
                        offWaitTime: WritableAttribute<number, any>;
                        onTime: WritableAttribute<number, any>;
                        startUpOnOff: WritableAttribute<(...) | (...), any>;
                    };
                    commands: {
                        offWithEffect: Command<TypeFromFields<(...)>, void, any>;
                        onWithRecallGlobalScene: Command<void, void, any>;
                        onWithTimedOff: Command<TypeFromFields<(...)>, void, any>;
                    };
                };
                flags: {
                    lighting: true;
                };
            }, {
                component: {
                    commands: {
                        on: Command<void, void, any>;
                        toggle: Command<void, void, any>;
                    };
                };
                flags: {
                    offOnly: false;
                };
            }, {
                component: false;
                flags: {
                    lighting: true;
                    offOnly: true;
                };
            }, {
                component: false;
                flags: {
                    deadFrontBehavior: true;
                    offOnly: true;
                };
            }, {
                component: false;
                flags: {
                    deadFrontBehavior: true;
                    lighting: false;
                    offOnly: true;
                };
            }];
            features: {
                deadFrontBehavior: BitFlag;
                lighting: BitFlag;
                offOnly: BitFlag;
            };
            id: 6;
            name: "OnOff";
            revision: 6;
        }>;
        commands: {
            off: Command<void, void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    globalSceneControl: Attribute<boolean, any>;
                    offWaitTime: WritableAttribute<number, any>;
                    onTime: WritableAttribute<number, any>;
                    startUpOnOff: WritableAttribute<null | OnOff.StartUpOnOff, any>;
                };
                commands: {
                    offWithEffect: Command<TypeFromFields<{
                        effectIdentifier: FieldType<(...)>;
                        effectVariant: FieldType<(...)>;
                    }>, void, any>;
                    onWithRecallGlobalScene: Command<void, void, any>;
                    onWithTimedOff: Command<TypeFromFields<{
                        offWaitTime: FieldType<(...)>;
                        onOffControl: FieldType<(...)>;
                        onTime: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                lighting: true;
            };
        }, {
            component: {
                commands: {
                    on: Command<void, void, any>;
                    toggle: Command<void, void, any>;
                };
            };
            flags: {
                offOnly: false;
            };
        }, {
            component: false;
            flags: {
                lighting: true;
                offOnly: true;
            };
        }, {
            component: false;
            flags: {
                deadFrontBehavior: true;
                offOnly: true;
            };
        }, {
            component: false;
            flags: {
                deadFrontBehavior: true;
                lighting: false;
                offOnly: true;
            };
        }];
        features: {
            deadFrontBehavior: BitFlag;
            lighting: BitFlag;
            offOnly: BitFlag;
        };
        id: 6;
        name: "OnOff";
        revision: 6;
    }>, SelectionT>

  • Select features using ClusterComposer.compose.

    Type Parameters

    • const SelectionT extends FeatureSelection<Of<{
          attributes: {
              onOff: Attribute<boolean, any>;
          };
          base: Of<{
              attributes: {
                  onOff: Attribute<boolean, any>;
              };
              commands: {
                  off: Command<void, void, any>;
              };
              extensions: readonly [{
                  component: {
                      attributes: {
                          globalSceneControl: Attribute<boolean, any>;
                          offWaitTime: WritableAttribute<number, any>;
                          onTime: WritableAttribute<number, any>;
                          startUpOnOff: WritableAttribute<(...) | (...), any>;
                      };
                      commands: {
                          offWithEffect: Command<TypeFromFields<(...)>, void, any>;
                          onWithRecallGlobalScene: Command<void, void, any>;
                          onWithTimedOff: Command<TypeFromFields<(...)>, void, any>;
                      };
                  };
                  flags: {
                      lighting: true;
                  };
              }, {
                  component: {
                      commands: {
                          on: Command<void, void, any>;
                          toggle: Command<void, void, any>;
                      };
                  };
                  flags: {
                      offOnly: false;
                  };
              }, {
                  component: false;
                  flags: {
                      lighting: true;
                      offOnly: true;
                  };
              }, {
                  component: false;
                  flags: {
                      deadFrontBehavior: true;
                      offOnly: true;
                  };
              }, {
                  component: false;
                  flags: {
                      deadFrontBehavior: true;
                      lighting: false;
                      offOnly: true;
                  };
              }];
              features: {
                  deadFrontBehavior: BitFlag;
                  lighting: BitFlag;
                  offOnly: BitFlag;
              };
              id: 6;
              name: "OnOff";
              revision: 6;
          }>;
          commands: {
              off: Command<void, void, any>;
          };
          extensions: readonly [{
              component: {
                  attributes: {
                      globalSceneControl: Attribute<boolean, any>;
                      offWaitTime: WritableAttribute<number, any>;
                      onTime: WritableAttribute<number, any>;
                      startUpOnOff: WritableAttribute<null | OnOff.StartUpOnOff, any>;
                  };
                  commands: {
                      offWithEffect: Command<TypeFromFields<{
                          effectIdentifier: FieldType<(...)>;
                          effectVariant: FieldType<(...)>;
                      }>, void, any>;
                      onWithRecallGlobalScene: Command<void, void, any>;
                      onWithTimedOff: Command<TypeFromFields<{
                          offWaitTime: FieldType<(...)>;
                          onOffControl: FieldType<(...)>;
                          onTime: FieldType<(...)>;
                      }>, void, any>;
                  };
              };
              flags: {
                  lighting: true;
              };
          }, {
              component: {
                  commands: {
                      on: Command<void, void, any>;
                      toggle: Command<void, void, any>;
                  };
              };
              flags: {
                  offOnly: false;
              };
          }, {
              component: false;
              flags: {
                  lighting: true;
                  offOnly: true;
              };
          }, {
              component: false;
              flags: {
                  deadFrontBehavior: true;
                  offOnly: true;
              };
          }, {
              component: false;
              flags: {
                  deadFrontBehavior: true;
                  lighting: false;
                  offOnly: true;
              };
          }];
          features: {
              deadFrontBehavior: BitFlag;
              lighting: BitFlag;
              offOnly: BitFlag;
          };
          id: 6;
          name: "OnOff";
          revision: 6;
      }>>

    Parameters

    Returns Of<Of<{
        attributes: {
            onOff: Attribute<boolean, any>;
        };
        base: Of<{
            attributes: {
                onOff: Attribute<boolean, any>;
            };
            commands: {
                off: Command<void, void, any>;
            };
            extensions: readonly [{
                component: {
                    attributes: {
                        globalSceneControl: Attribute<boolean, any>;
                        offWaitTime: WritableAttribute<number, any>;
                        onTime: WritableAttribute<number, any>;
                        startUpOnOff: WritableAttribute<(...) | (...), any>;
                    };
                    commands: {
                        offWithEffect: Command<TypeFromFields<(...)>, void, any>;
                        onWithRecallGlobalScene: Command<void, void, any>;
                        onWithTimedOff: Command<TypeFromFields<(...)>, void, any>;
                    };
                };
                flags: {
                    lighting: true;
                };
            }, {
                component: {
                    commands: {
                        on: Command<void, void, any>;
                        toggle: Command<void, void, any>;
                    };
                };
                flags: {
                    offOnly: false;
                };
            }, {
                component: false;
                flags: {
                    lighting: true;
                    offOnly: true;
                };
            }, {
                component: false;
                flags: {
                    deadFrontBehavior: true;
                    offOnly: true;
                };
            }, {
                component: false;
                flags: {
                    deadFrontBehavior: true;
                    lighting: false;
                    offOnly: true;
                };
            }];
            features: {
                deadFrontBehavior: BitFlag;
                lighting: BitFlag;
                offOnly: BitFlag;
            };
            id: 6;
            name: "OnOff";
            revision: 6;
        }>;
        commands: {
            off: Command<void, void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    globalSceneControl: Attribute<boolean, any>;
                    offWaitTime: WritableAttribute<number, any>;
                    onTime: WritableAttribute<number, any>;
                    startUpOnOff: WritableAttribute<null | OnOff.StartUpOnOff, any>;
                };
                commands: {
                    offWithEffect: Command<TypeFromFields<{
                        effectIdentifier: FieldType<(...)>;
                        effectVariant: FieldType<(...)>;
                    }>, void, any>;
                    onWithRecallGlobalScene: Command<void, void, any>;
                    onWithTimedOff: Command<TypeFromFields<{
                        offWaitTime: FieldType<(...)>;
                        onOffControl: FieldType<(...)>;
                        onTime: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                lighting: true;
            };
        }, {
            component: {
                commands: {
                    on: Command<void, void, any>;
                    toggle: Command<void, void, any>;
                };
            };
            flags: {
                offOnly: false;
            };
        }, {
            component: false;
            flags: {
                lighting: true;
                offOnly: true;
            };
        }, {
            component: false;
            flags: {
                deadFrontBehavior: true;
                offOnly: true;
            };
        }, {
            component: false;
            flags: {
                deadFrontBehavior: true;
                lighting: false;
                offOnly: true;
            };
        }];
        features: {
            deadFrontBehavior: BitFlag;
            lighting: BitFlag;
            offOnly: BitFlag;
        };
        id: 6;
        name: "OnOff";
        revision: 6;
    }>, SelectionT>

Settings

Member Visibility

On This Page

Properties
Methods