Interface Complete

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

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

interface Complete {
    attributes: Merge<{
        acceptedCommandList: Attribute<CommandId[], never>;
        attributeList: Attribute<AttributeId[], never>;
        clusterRevision: Attribute<number, never>;
        currentFrequency: Attribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                frequency: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        currentLevel: Attribute<null | number, any>;
        defaultMoveRate: OptionalWritableAttribute<null | number, any>;
        featureMap: Attribute<TypeFromPartialBitSchema<{
            frequency: BitFlag;
            lighting: BitFlag;
            onOff: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        maxFrequency: Attribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                frequency: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        maxLevel: OptionalAttribute<number, any>;
        minFrequency: Attribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                frequency: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        minLevel: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                lighting: boolean;
            }];
        };
        offTransitionTime: OptionalWritableAttribute<null | number, any>;
        onLevel: WritableAttribute<null | number, any>;
        onOffTransitionTime: OptionalWritableAttribute<number, any>;
        onTransitionTime: OptionalWritableAttribute<null | number, any>;
        options: WritableAttribute<TypeFromPartialBitSchema<{
            coupleColorTempToLevel: BitFlag;
            executeIfOff: BitFlag;
        }>, any>;
        remainingTime: Attribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                lighting: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        startUpCurrentLevel: WritableAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                lighting: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    }, GlobalAttributes<{
        frequency: BitFlag;
        lighting: BitFlag;
        onOff: BitFlag;
    }>>;
    base: undefined;
    commands: {
        move: Command<TypeFromFields<{
            moveMode: FieldType<LevelControl.MoveMode>;
            optionsMask: FieldType<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: BitFlag;
                executeIfOff: BitFlag;
            }>>;
            optionsOverride: FieldType<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: BitFlag;
                executeIfOff: BitFlag;
            }>>;
            rate: FieldType<null | number>;
        }>, void, any>;
        moveToClosestFrequency: Command<TypeFromFields<{
            frequency: FieldType<number>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                frequency: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        moveToLevel: Command<TypeFromFields<{
            level: FieldType<number>;
            optionsMask: FieldType<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: BitFlag;
                executeIfOff: BitFlag;
            }>>;
            optionsOverride: FieldType<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: BitFlag;
                executeIfOff: BitFlag;
            }>>;
            transitionTime: FieldType<null | number>;
        }>, void, any>;
        moveToLevelWithOnOff: Command<TypeFromFields<{
            level: FieldType<number>;
            optionsMask: FieldType<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: BitFlag;
                executeIfOff: BitFlag;
            }>>;
            optionsOverride: FieldType<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: BitFlag;
                executeIfOff: BitFlag;
            }>>;
            transitionTime: FieldType<null | number>;
        }>, void, any>;
        moveWithOnOff: Command<TypeFromFields<{
            moveMode: FieldType<LevelControl.MoveMode>;
            optionsMask: FieldType<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: BitFlag;
                executeIfOff: BitFlag;
            }>>;
            optionsOverride: FieldType<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: BitFlag;
                executeIfOff: BitFlag;
            }>>;
            rate: FieldType<null | number>;
        }>, void, any>;
        step: Command<TypeFromFields<{
            optionsMask: FieldType<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: BitFlag;
                executeIfOff: BitFlag;
            }>>;
            optionsOverride: FieldType<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: BitFlag;
                executeIfOff: BitFlag;
            }>>;
            stepMode: FieldType<LevelControl.StepMode>;
            stepSize: FieldType<number>;
            transitionTime: FieldType<null | number>;
        }>, void, any>;
        stepWithOnOff: Command<TypeFromFields<{
            optionsMask: FieldType<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: BitFlag;
                executeIfOff: BitFlag;
            }>>;
            optionsOverride: FieldType<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: BitFlag;
                executeIfOff: BitFlag;
            }>>;
            stepMode: FieldType<LevelControl.StepMode>;
            stepSize: FieldType<number>;
            transitionTime: FieldType<null | number>;
        }>, void, any>;
        stop: Command<TypeFromFields<{
            optionsMask: FieldType<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: BitFlag;
                executeIfOff: BitFlag;
            }>>;
            optionsOverride: FieldType<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: BitFlag;
                executeIfOff: BitFlag;
            }>>;
        }>, void, any>;
        stopWithOnOff: Command<TypeFromFields<{
            optionsMask: FieldType<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: BitFlag;
                executeIfOff: BitFlag;
            }>>;
            optionsOverride: FieldType<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: BitFlag;
                executeIfOff: BitFlag;
            }>>;
        }>, void, any>;
    };
    events: {};
    extensions: undefined;
    features: {
        frequency: BitFlag;
        lighting: BitFlag;
        onOff: BitFlag;
    };
    id: Branded<Branded<8, "ClusterId">, "ClusterId">;
    name: "LevelControl";
    revision: 5;
    supportedFeatures: {};
    unknown: false;
    alter<const AlterationsT>(alterations: AlterationsT): WithAlterations<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            clusterRevision: Attribute<number, never>;
            currentFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    frequency: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            currentLevel: Attribute<null | number, any>;
            defaultMoveRate: OptionalWritableAttribute<null | number, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                frequency: BitFlag;
                lighting: BitFlag;
                onOff: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maxFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    frequency: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            maxLevel: OptionalAttribute<number, any>;
            minFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    frequency: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minLevel: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    lighting: boolean;
                }];
            };
            offTransitionTime: OptionalWritableAttribute<null | number, any>;
            onLevel: WritableAttribute<null | number, any>;
            onOffTransitionTime: OptionalWritableAttribute<number, any>;
            onTransitionTime: OptionalWritableAttribute<null | number, any>;
            options: WritableAttribute<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: BitFlag;
                executeIfOff: BitFlag;
            }>, any>;
            remainingTime: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lighting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            startUpCurrentLevel: WritableAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lighting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            move: Command<TypeFromFields<{
                moveMode: FieldType<LevelControl.MoveMode>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                rate: FieldType<null | number>;
            }>, void, any>;
            moveToClosestFrequency: Command<TypeFromFields<{
                frequency: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    frequency: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            moveToLevel: Command<TypeFromFields<{
                level: FieldType<number>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                transitionTime: FieldType<null | number>;
            }>, void, any>;
            moveToLevelWithOnOff: Command<TypeFromFields<{
                level: FieldType<number>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                transitionTime: FieldType<null | number>;
            }>, void, any>;
            moveWithOnOff: Command<TypeFromFields<{
                moveMode: FieldType<LevelControl.MoveMode>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                rate: FieldType<null | number>;
            }>, void, any>;
            step: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                stepMode: FieldType<LevelControl.StepMode>;
                stepSize: FieldType<number>;
                transitionTime: FieldType<null | number>;
            }>, void, any>;
            stepWithOnOff: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                stepMode: FieldType<LevelControl.StepMode>;
                stepSize: FieldType<number>;
                transitionTime: FieldType<null | number>;
            }>, void, any>;
            stop: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
            }>, void, any>;
            stopWithOnOff: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
            }>, void, any>;
        };
        features: {
            frequency: BitFlag;
            lighting: BitFlag;
            onOff: BitFlag;
        };
        id: Branded<8, "ClusterId">;
        name: "LevelControl";
        revision: 5;
    }>, AlterationsT>;
    enable<const FlagsT>(flags: FlagsT): WithFlags<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            clusterRevision: Attribute<number, never>;
            currentFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    frequency: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            currentLevel: Attribute<null | number, any>;
            defaultMoveRate: OptionalWritableAttribute<null | number, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                frequency: BitFlag;
                lighting: BitFlag;
                onOff: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maxFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    frequency: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            maxLevel: OptionalAttribute<number, any>;
            minFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    frequency: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minLevel: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    lighting: boolean;
                }];
            };
            offTransitionTime: OptionalWritableAttribute<null | number, any>;
            onLevel: WritableAttribute<null | number, any>;
            onOffTransitionTime: OptionalWritableAttribute<number, any>;
            onTransitionTime: OptionalWritableAttribute<null | number, any>;
            options: WritableAttribute<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: BitFlag;
                executeIfOff: BitFlag;
            }>, any>;
            remainingTime: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lighting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            startUpCurrentLevel: WritableAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lighting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            move: Command<TypeFromFields<{
                moveMode: FieldType<LevelControl.MoveMode>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                rate: FieldType<null | number>;
            }>, void, any>;
            moveToClosestFrequency: Command<TypeFromFields<{
                frequency: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    frequency: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            moveToLevel: Command<TypeFromFields<{
                level: FieldType<number>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                transitionTime: FieldType<null | number>;
            }>, void, any>;
            moveToLevelWithOnOff: Command<TypeFromFields<{
                level: FieldType<number>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                transitionTime: FieldType<null | number>;
            }>, void, any>;
            moveWithOnOff: Command<TypeFromFields<{
                moveMode: FieldType<LevelControl.MoveMode>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                rate: FieldType<null | number>;
            }>, void, any>;
            step: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                stepMode: FieldType<LevelControl.StepMode>;
                stepSize: FieldType<number>;
                transitionTime: FieldType<null | number>;
            }>, void, any>;
            stepWithOnOff: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                stepMode: FieldType<LevelControl.StepMode>;
                stepSize: FieldType<number>;
                transitionTime: FieldType<null | number>;
            }>, void, any>;
            stop: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
            }>, void, any>;
            stopWithOnOff: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
            }>, void, any>;
        };
        features: {
            frequency: BitFlag;
            lighting: BitFlag;
            onOff: BitFlag;
        };
        id: Branded<8, "ClusterId">;
        name: "LevelControl";
        revision: 5;
    }>, FlagsT>;
    set<const ValuesT>(values: ValuesT): WithValues<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            clusterRevision: Attribute<number, never>;
            currentFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    frequency: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            currentLevel: Attribute<null | number, any>;
            defaultMoveRate: OptionalWritableAttribute<null | number, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                frequency: BitFlag;
                lighting: BitFlag;
                onOff: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maxFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    frequency: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            maxLevel: OptionalAttribute<number, any>;
            minFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    frequency: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minLevel: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    lighting: boolean;
                }];
            };
            offTransitionTime: OptionalWritableAttribute<null | number, any>;
            onLevel: WritableAttribute<null | number, any>;
            onOffTransitionTime: OptionalWritableAttribute<number, any>;
            onTransitionTime: OptionalWritableAttribute<null | number, any>;
            options: WritableAttribute<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: BitFlag;
                executeIfOff: BitFlag;
            }>, any>;
            remainingTime: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lighting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            startUpCurrentLevel: WritableAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lighting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            move: Command<TypeFromFields<{
                moveMode: FieldType<LevelControl.MoveMode>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                rate: FieldType<null | number>;
            }>, void, any>;
            moveToClosestFrequency: Command<TypeFromFields<{
                frequency: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    frequency: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            moveToLevel: Command<TypeFromFields<{
                level: FieldType<number>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                transitionTime: FieldType<null | number>;
            }>, void, any>;
            moveToLevelWithOnOff: Command<TypeFromFields<{
                level: FieldType<number>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                transitionTime: FieldType<null | number>;
            }>, void, any>;
            moveWithOnOff: Command<TypeFromFields<{
                moveMode: FieldType<LevelControl.MoveMode>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                rate: FieldType<null | number>;
            }>, void, any>;
            step: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                stepMode: FieldType<LevelControl.StepMode>;
                stepSize: FieldType<number>;
                transitionTime: FieldType<null | number>;
            }>, void, any>;
            stepWithOnOff: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                stepMode: FieldType<LevelControl.StepMode>;
                stepSize: FieldType<number>;
                transitionTime: FieldType<null | number>;
            }>, void, any>;
            stop: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
            }>, void, any>;
            stopWithOnOff: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
            }>, void, any>;
        };
        features: {
            frequency: BitFlag;
            lighting: BitFlag;
            onOff: BitFlag;
        };
        id: Branded<8, "ClusterId">;
        name: "LevelControl";
        revision: 5;
    }>, ValuesT>;
    with<const SelectionT>(...selection: SelectionT): Of<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            clusterRevision: Attribute<number, never>;
            currentFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    frequency: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            currentLevel: Attribute<null | number, any>;
            defaultMoveRate: OptionalWritableAttribute<null | number, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                frequency: BitFlag;
                lighting: BitFlag;
                onOff: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maxFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    frequency: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            maxLevel: OptionalAttribute<number, any>;
            minFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    frequency: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minLevel: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    lighting: boolean;
                }];
            };
            offTransitionTime: OptionalWritableAttribute<null | number, any>;
            onLevel: WritableAttribute<null | number, any>;
            onOffTransitionTime: OptionalWritableAttribute<number, any>;
            onTransitionTime: OptionalWritableAttribute<null | number, any>;
            options: WritableAttribute<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: BitFlag;
                executeIfOff: BitFlag;
            }>, any>;
            remainingTime: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lighting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            startUpCurrentLevel: WritableAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lighting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            move: Command<TypeFromFields<{
                moveMode: FieldType<LevelControl.MoveMode>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                rate: FieldType<null | number>;
            }>, void, any>;
            moveToClosestFrequency: Command<TypeFromFields<{
                frequency: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    frequency: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            moveToLevel: Command<TypeFromFields<{
                level: FieldType<number>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                transitionTime: FieldType<null | number>;
            }>, void, any>;
            moveToLevelWithOnOff: Command<TypeFromFields<{
                level: FieldType<number>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                transitionTime: FieldType<null | number>;
            }>, void, any>;
            moveWithOnOff: Command<TypeFromFields<{
                moveMode: FieldType<LevelControl.MoveMode>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                rate: FieldType<null | number>;
            }>, void, any>;
            step: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                stepMode: FieldType<LevelControl.StepMode>;
                stepSize: FieldType<number>;
                transitionTime: FieldType<null | number>;
            }>, void, any>;
            stepWithOnOff: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                stepMode: FieldType<LevelControl.StepMode>;
                stepSize: FieldType<number>;
                transitionTime: FieldType<null | number>;
            }>, void, any>;
            stop: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
            }>, void, any>;
            stopWithOnOff: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
            }>, void, any>;
        };
        features: {
            frequency: BitFlag;
            lighting: BitFlag;
            onOff: BitFlag;
        };
        id: Branded<8, "ClusterId">;
        name: "LevelControl";
        revision: 5;
    }>, SelectionT>;
}

Hierarchy (view full)

Properties

attributes base commands events extensions features id name revision supportedFeatures unknown

Methods

alter enable set with

Properties

attributes

attributes: Merge<{
    acceptedCommandList: Attribute<CommandId[], never>;
    attributeList: Attribute<AttributeId[], never>;
    clusterRevision: Attribute<number, never>;
    currentFrequency: Attribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            frequency: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    currentLevel: Attribute<null | number, any>;
    defaultMoveRate: OptionalWritableAttribute<null | number, any>;
    featureMap: Attribute<TypeFromPartialBitSchema<{
        frequency: BitFlag;
        lighting: BitFlag;
        onOff: BitFlag;
    }>, never>;
    generatedCommandList: Attribute<CommandId[], never>;
    maxFrequency: Attribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            frequency: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    maxLevel: OptionalAttribute<number, any>;
    minFrequency: Attribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            frequency: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    minLevel: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            lighting: boolean;
        }];
    };
    offTransitionTime: OptionalWritableAttribute<null | number, any>;
    onLevel: WritableAttribute<null | number, any>;
    onOffTransitionTime: OptionalWritableAttribute<number, any>;
    onTransitionTime: OptionalWritableAttribute<null | number, any>;
    options: WritableAttribute<TypeFromPartialBitSchema<{
        coupleColorTempToLevel: BitFlag;
        executeIfOff: BitFlag;
    }>, any>;
    remainingTime: Attribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            lighting: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    startUpCurrentLevel: WritableAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            lighting: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
}, GlobalAttributes<{
    frequency: BitFlag;
    lighting: BitFlag;
    onOff: BitFlag;
}>>

Type declaration

  • ReadonlyacceptedCommandList: Attribute<CommandId[], never>

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

  • ReadonlyattributeList: Attribute<AttributeId[], never>

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

  • ReadonlyclusterRevision: Attribute<number, never>

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

  • ReadonlycurrentFrequency: Attribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            frequency: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlycurrentLevel: Attribute<null | number, any>

    Indicates the current level of this device. The meaning of 'level' is device dependent.

    See

    MatterSpecification.v13.Cluster § 1.6.6.2

  • ReadonlydefaultMoveRate: OptionalWritableAttribute<null | number, any>

    Indicates the movement rate, in units per second, when a Move command is received with a null value Rate parameter.

    See

    MatterSpecification.v13.Cluster § 1.6.6.14

  • ReadonlyfeatureMap: Attribute<TypeFromPartialBitSchema<{
        frequency: BitFlag;
        lighting: BitFlag;
        onOff: BitFlag;
    }>, never>

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

  • ReadonlygeneratedCommandList: Attribute<CommandId[], never>

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

  • ReadonlymaxFrequency: Attribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            frequency: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlymaxLevel: OptionalAttribute<number, any>

    Indicates the maximum value of CurrentLevel that is capable of being assigned.

    See

    MatterSpecification.v13.Cluster § 1.6.6.5

  • ReadonlyminFrequency: Attribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            frequency: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlyminLevel: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            lighting: boolean;
        }];
    }
  • ReadonlyoffTransitionTime: OptionalWritableAttribute<null | number, any>

    Indicates the time taken to move the current level from the maximum level to the minimum level when an Off command is received by an On/Off cluster on the same endpoint. It is specified in 1/10ths of a second. If this attribute is not implemented, or contains a null value, the OnOffTransitionTime shall be used instead.

    See

    MatterSpecification.v13.Cluster § 1.6.6.13

  • ReadonlyonLevel: WritableAttribute<null | number, any>

    Indicates the value that the CurrentLevel attribute is set to when the OnOff attribute of an On/Off cluster on the same endpoint is set to TRUE, as a result of processing an On/Off cluster command. If the OnLevel attribute is not implemented, or is set to the null value, it has no effect. For more details see Effect of On/Off Commands on the CurrentLevel Attribute.

    OnLevel represents a mandatory field that was previously not present or optional. Implementers should be aware that older devices may not implement it.

    See

    MatterSpecification.v13.Cluster § 1.6.6.11

  • ReadonlyonOffTransitionTime: OptionalWritableAttribute<number, any>

    Indicates the time taken to move to or from the target level when On or Off commands are received by an On/Off cluster on the same endpoint. It is specified in 1/10ths of a second.

    The actual time taken SHOULD be as close to OnOffTransitionTime as the device is able. Please note that if the device is not able to move at a variable rate, the OnOffTransitionTime attribute SHOULD NOT be implemented.

    See

    MatterSpecification.v13.Cluster § 1.6.6.10

  • ReadonlyonTransitionTime: OptionalWritableAttribute<null | number, any>

    Indicates the time taken to move the current level from the minimum level to the maximum level when an On command is received by an On/Off cluster on the same endpoint. It is specified in 1/10ths of a second. If this attribute is not implemented, or contains a null value, the OnOffTransitionTime shall be used instead.

    See

    MatterSpecification.v13.Cluster § 1.6.6.12

  • Readonlyoptions: WritableAttribute<TypeFromPartialBitSchema<{
        coupleColorTempToLevel: BitFlag;
        executeIfOff: BitFlag;
    }>, any>

    Indicates the selected options of the device.

    The Options attribute is a bitmap that determines the default behavior of some cluster commands. Each command that is dependent on the Options attribute shall first construct a temporary Options bitmap that is in effect during the command processing. The temporary Options bitmap has the same format and meaning as the Options attribute, but includes any bits that may be overridden by command fields.

    This attribute is meant to be changed only during commissioning.

    Command execution shall NOT continue beyond the Options processing if all of these criteria are true:

    • The command is one of the ‘without On/Off’ commands: Move, Move to Level, Step, or Stop.

    • The On/Off cluster exists on the same endpoint as this cluster.

    • The OnOff attribute of the On/Off cluster, on this endpoint, is FALSE.

    • The value of the ExecuteIfOff bit is 0.

    See

    MatterSpecification.v13.Cluster § 1.6.6.9

  • ReadonlyremainingTime: Attribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            lighting: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlystartUpCurrentLevel: WritableAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            lighting: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }

base

base: undefined

commands

commands: {
    move: Command<TypeFromFields<{
        moveMode: FieldType<LevelControl.MoveMode>;
        optionsMask: FieldType<TypeFromPartialBitSchema<{
            coupleColorTempToLevel: BitFlag;
            executeIfOff: BitFlag;
        }>>;
        optionsOverride: FieldType<TypeFromPartialBitSchema<{
            coupleColorTempToLevel: BitFlag;
            executeIfOff: BitFlag;
        }>>;
        rate: FieldType<null | number>;
    }>, void, any>;
    moveToClosestFrequency: Command<TypeFromFields<{
        frequency: FieldType<number>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            frequency: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    moveToLevel: Command<TypeFromFields<{
        level: FieldType<number>;
        optionsMask: FieldType<TypeFromPartialBitSchema<{
            coupleColorTempToLevel: BitFlag;
            executeIfOff: BitFlag;
        }>>;
        optionsOverride: FieldType<TypeFromPartialBitSchema<{
            coupleColorTempToLevel: BitFlag;
            executeIfOff: BitFlag;
        }>>;
        transitionTime: FieldType<null | number>;
    }>, void, any>;
    moveToLevelWithOnOff: Command<TypeFromFields<{
        level: FieldType<number>;
        optionsMask: FieldType<TypeFromPartialBitSchema<{
            coupleColorTempToLevel: BitFlag;
            executeIfOff: BitFlag;
        }>>;
        optionsOverride: FieldType<TypeFromPartialBitSchema<{
            coupleColorTempToLevel: BitFlag;
            executeIfOff: BitFlag;
        }>>;
        transitionTime: FieldType<null | number>;
    }>, void, any>;
    moveWithOnOff: Command<TypeFromFields<{
        moveMode: FieldType<LevelControl.MoveMode>;
        optionsMask: FieldType<TypeFromPartialBitSchema<{
            coupleColorTempToLevel: BitFlag;
            executeIfOff: BitFlag;
        }>>;
        optionsOverride: FieldType<TypeFromPartialBitSchema<{
            coupleColorTempToLevel: BitFlag;
            executeIfOff: BitFlag;
        }>>;
        rate: FieldType<null | number>;
    }>, void, any>;
    step: Command<TypeFromFields<{
        optionsMask: FieldType<TypeFromPartialBitSchema<{
            coupleColorTempToLevel: BitFlag;
            executeIfOff: BitFlag;
        }>>;
        optionsOverride: FieldType<TypeFromPartialBitSchema<{
            coupleColorTempToLevel: BitFlag;
            executeIfOff: BitFlag;
        }>>;
        stepMode: FieldType<LevelControl.StepMode>;
        stepSize: FieldType<number>;
        transitionTime: FieldType<null | number>;
    }>, void, any>;
    stepWithOnOff: Command<TypeFromFields<{
        optionsMask: FieldType<TypeFromPartialBitSchema<{
            coupleColorTempToLevel: BitFlag;
            executeIfOff: BitFlag;
        }>>;
        optionsOverride: FieldType<TypeFromPartialBitSchema<{
            coupleColorTempToLevel: BitFlag;
            executeIfOff: BitFlag;
        }>>;
        stepMode: FieldType<LevelControl.StepMode>;
        stepSize: FieldType<number>;
        transitionTime: FieldType<null | number>;
    }>, void, any>;
    stop: Command<TypeFromFields<{
        optionsMask: FieldType<TypeFromPartialBitSchema<{
            coupleColorTempToLevel: BitFlag;
            executeIfOff: BitFlag;
        }>>;
        optionsOverride: FieldType<TypeFromPartialBitSchema<{
            coupleColorTempToLevel: BitFlag;
            executeIfOff: BitFlag;
        }>>;
    }>, void, any>;
    stopWithOnOff: Command<TypeFromFields<{
        optionsMask: FieldType<TypeFromPartialBitSchema<{
            coupleColorTempToLevel: BitFlag;
            executeIfOff: BitFlag;
        }>>;
        optionsOverride: FieldType<TypeFromPartialBitSchema<{
            coupleColorTempToLevel: BitFlag;
            executeIfOff: BitFlag;
        }>>;
    }>, void, any>;
}

Type declaration

events

events: {}

extensions

extensions: undefined

features

features: {
    frequency: BitFlag;
    lighting: BitFlag;
    onOff: BitFlag;
}

Type declaration

  • Readonlyfrequency: BitFlag

    Frequency

    NOTE The Frequency feature is provisional.

    See

    MatterSpecification.v13.Cluster § 1.6.4.3

  • Readonlylighting: BitFlag

    Lighting

    This feature supports an interface for controlling the level of a light source. For the CurrentLevel attribute:

    A value of 0x00 shall NOT be used.

    A value of 0x01 shall indicate the minimum level that can be attained on a device. A value of 0xFE shall indicate the maximum level that can be attained on a device. A value of null shall represent an undefined value.

    All other values are application specific gradations from the minimum to the maximum level.

    See

    MatterSpecification.v13.Cluster § 1.6.4.2

  • ReadonlyonOff: BitFlag

    OnOff

    Dependency with the On/Off cluster

id

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

name

name

revision

revision

supportedFeatures

supportedFeatures: {}

unknown

unknown

Methods

alter

  • alter<const AlterationsT>(alterations): WithAlterations<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            clusterRevision: Attribute<number, never>;
            currentFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    frequency: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            currentLevel: Attribute<null | number, any>;
            defaultMoveRate: OptionalWritableAttribute<null | number, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                frequency: BitFlag;
                lighting: BitFlag;
                onOff: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maxFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    frequency: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            maxLevel: OptionalAttribute<number, any>;
            minFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    frequency: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minLevel: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    lighting: boolean;
                }];
            };
            offTransitionTime: OptionalWritableAttribute<null | number, any>;
            onLevel: WritableAttribute<null | number, any>;
            onOffTransitionTime: OptionalWritableAttribute<number, any>;
            onTransitionTime: OptionalWritableAttribute<null | number, any>;
            options: WritableAttribute<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: BitFlag;
                executeIfOff: BitFlag;
            }>, any>;
            remainingTime: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lighting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            startUpCurrentLevel: WritableAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lighting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            move: Command<TypeFromFields<{
                moveMode: FieldType<LevelControl.MoveMode>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                rate: FieldType<null | number>;
            }>, void, any>;
            moveToClosestFrequency: Command<TypeFromFields<{
                frequency: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    frequency: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            moveToLevel: Command<TypeFromFields<{
                level: FieldType<number>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                transitionTime: FieldType<null | number>;
            }>, void, any>;
            moveToLevelWithOnOff: Command<TypeFromFields<{
                level: FieldType<number>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                transitionTime: FieldType<null | number>;
            }>, void, any>;
            moveWithOnOff: Command<TypeFromFields<{
                moveMode: FieldType<LevelControl.MoveMode>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                rate: FieldType<null | number>;
            }>, void, any>;
            step: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                stepMode: FieldType<LevelControl.StepMode>;
                stepSize: FieldType<number>;
                transitionTime: FieldType<null | number>;
            }>, void, any>;
            stepWithOnOff: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                stepMode: FieldType<LevelControl.StepMode>;
                stepSize: FieldType<number>;
                transitionTime: FieldType<null | number>;
            }>, void, any>;
            stop: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
            }>, void, any>;
            stopWithOnOff: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
            }>, void, any>;
        };
        features: {
            frequency: BitFlag;
            lighting: BitFlag;
            onOff: BitFlag;
        };
        id: Branded<8, "ClusterId">;
        name: "LevelControl";
        revision: 5;
    }>, AlterationsT>

  • Modify elements using ElementModifier.alter.

    Type Parameters

    • const AlterationsT extends Alterations<Of<{
          attributes: {
              acceptedCommandList: Attribute<CommandId[], never>;
              attributeList: Attribute<AttributeId[], never>;
              clusterRevision: Attribute<number, never>;
              currentFrequency: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      frequency: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              currentLevel: Attribute<null | number, any>;
              defaultMoveRate: OptionalWritableAttribute<null | number, any>;
              featureMap: Attribute<TypeFromPartialBitSchema<{
                  frequency: BitFlag;
                  lighting: BitFlag;
                  onOff: BitFlag;
              }>, never>;
              generatedCommandList: Attribute<CommandId[], never>;
              maxFrequency: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      frequency: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              maxLevel: OptionalAttribute<number, any>;
              minFrequency: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      frequency: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              minLevel: OptionalAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      lighting: boolean;
                  }];
              };
              offTransitionTime: OptionalWritableAttribute<null | number, any>;
              onLevel: WritableAttribute<null | number, any>;
              onOffTransitionTime: OptionalWritableAttribute<number, any>;
              onTransitionTime: OptionalWritableAttribute<null | number, any>;
              options: WritableAttribute<TypeFromPartialBitSchema<{
                  coupleColorTempToLevel: BitFlag;
                  executeIfOff: BitFlag;
              }>, any>;
              remainingTime: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      lighting: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              startUpCurrentLevel: WritableAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      lighting: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          commands: {
              move: Command<TypeFromFields<{
                  moveMode: FieldType<LevelControl.MoveMode>;
                  optionsMask: FieldType<TypeFromPartialBitSchema<{
                      coupleColorTempToLevel: BitFlag;
                      executeIfOff: BitFlag;
                  }>>;
                  optionsOverride: FieldType<TypeFromPartialBitSchema<{
                      coupleColorTempToLevel: BitFlag;
                      executeIfOff: BitFlag;
                  }>>;
                  rate: FieldType<null | number>;
              }>, void, any>;
              moveToClosestFrequency: Command<TypeFromFields<{
                  frequency: FieldType<number>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      frequency: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              moveToLevel: Command<TypeFromFields<{
                  level: FieldType<number>;
                  optionsMask: FieldType<TypeFromPartialBitSchema<{
                      coupleColorTempToLevel: BitFlag;
                      executeIfOff: BitFlag;
                  }>>;
                  optionsOverride: FieldType<TypeFromPartialBitSchema<{
                      coupleColorTempToLevel: BitFlag;
                      executeIfOff: BitFlag;
                  }>>;
                  transitionTime: FieldType<null | number>;
              }>, void, any>;
              moveToLevelWithOnOff: Command<TypeFromFields<{
                  level: FieldType<number>;
                  optionsMask: FieldType<TypeFromPartialBitSchema<{
                      coupleColorTempToLevel: BitFlag;
                      executeIfOff: BitFlag;
                  }>>;
                  optionsOverride: FieldType<TypeFromPartialBitSchema<{
                      coupleColorTempToLevel: BitFlag;
                      executeIfOff: BitFlag;
                  }>>;
                  transitionTime: FieldType<null | number>;
              }>, void, any>;
              moveWithOnOff: Command<TypeFromFields<{
                  moveMode: FieldType<LevelControl.MoveMode>;
                  optionsMask: FieldType<TypeFromPartialBitSchema<{
                      coupleColorTempToLevel: BitFlag;
                      executeIfOff: BitFlag;
                  }>>;
                  optionsOverride: FieldType<TypeFromPartialBitSchema<{
                      coupleColorTempToLevel: BitFlag;
                      executeIfOff: BitFlag;
                  }>>;
                  rate: FieldType<null | number>;
              }>, void, any>;
              step: Command<TypeFromFields<{
                  optionsMask: FieldType<TypeFromPartialBitSchema<{
                      coupleColorTempToLevel: BitFlag;
                      executeIfOff: BitFlag;
                  }>>;
                  optionsOverride: FieldType<TypeFromPartialBitSchema<{
                      coupleColorTempToLevel: BitFlag;
                      executeIfOff: BitFlag;
                  }>>;
                  stepMode: FieldType<LevelControl.StepMode>;
                  stepSize: FieldType<number>;
                  transitionTime: FieldType<null | number>;
              }>, void, any>;
              stepWithOnOff: Command<TypeFromFields<{
                  optionsMask: FieldType<TypeFromPartialBitSchema<{
                      coupleColorTempToLevel: BitFlag;
                      executeIfOff: BitFlag;
                  }>>;
                  optionsOverride: FieldType<TypeFromPartialBitSchema<{
                      coupleColorTempToLevel: BitFlag;
                      executeIfOff: BitFlag;
                  }>>;
                  stepMode: FieldType<LevelControl.StepMode>;
                  stepSize: FieldType<number>;
                  transitionTime: FieldType<null | number>;
              }>, void, any>;
              stop: Command<TypeFromFields<{
                  optionsMask: FieldType<TypeFromPartialBitSchema<{
                      coupleColorTempToLevel: BitFlag;
                      executeIfOff: BitFlag;
                  }>>;
                  optionsOverride: FieldType<TypeFromPartialBitSchema<{
                      coupleColorTempToLevel: BitFlag;
                      executeIfOff: BitFlag;
                  }>>;
              }>, void, any>;
              stopWithOnOff: Command<TypeFromFields<{
                  optionsMask: FieldType<TypeFromPartialBitSchema<{
                      coupleColorTempToLevel: BitFlag;
                      executeIfOff: BitFlag;
                  }>>;
                  optionsOverride: FieldType<TypeFromPartialBitSchema<{
                      coupleColorTempToLevel: BitFlag;
                      executeIfOff: BitFlag;
                  }>>;
              }>, void, any>;
          };
          features: {
              frequency: BitFlag;
              lighting: BitFlag;
              onOff: BitFlag;
          };
          id: Branded<8, "ClusterId">;
          name: "LevelControl";
          revision: 5;
      }>>

    Parameters

    Returns WithAlterations<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            clusterRevision: Attribute<number, never>;
            currentFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    frequency: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            currentLevel: Attribute<null | number, any>;
            defaultMoveRate: OptionalWritableAttribute<null | number, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                frequency: BitFlag;
                lighting: BitFlag;
                onOff: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maxFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    frequency: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            maxLevel: OptionalAttribute<number, any>;
            minFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    frequency: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minLevel: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    lighting: boolean;
                }];
            };
            offTransitionTime: OptionalWritableAttribute<null | number, any>;
            onLevel: WritableAttribute<null | number, any>;
            onOffTransitionTime: OptionalWritableAttribute<number, any>;
            onTransitionTime: OptionalWritableAttribute<null | number, any>;
            options: WritableAttribute<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: BitFlag;
                executeIfOff: BitFlag;
            }>, any>;
            remainingTime: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lighting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            startUpCurrentLevel: WritableAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lighting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            move: Command<TypeFromFields<{
                moveMode: FieldType<LevelControl.MoveMode>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                rate: FieldType<null | number>;
            }>, void, any>;
            moveToClosestFrequency: Command<TypeFromFields<{
                frequency: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    frequency: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            moveToLevel: Command<TypeFromFields<{
                level: FieldType<number>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                transitionTime: FieldType<null | number>;
            }>, void, any>;
            moveToLevelWithOnOff: Command<TypeFromFields<{
                level: FieldType<number>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                transitionTime: FieldType<null | number>;
            }>, void, any>;
            moveWithOnOff: Command<TypeFromFields<{
                moveMode: FieldType<LevelControl.MoveMode>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                rate: FieldType<null | number>;
            }>, void, any>;
            step: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                stepMode: FieldType<LevelControl.StepMode>;
                stepSize: FieldType<number>;
                transitionTime: FieldType<null | number>;
            }>, void, any>;
            stepWithOnOff: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                stepMode: FieldType<LevelControl.StepMode>;
                stepSize: FieldType<number>;
                transitionTime: FieldType<null | number>;
            }>, void, any>;
            stop: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
            }>, void, any>;
            stopWithOnOff: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
            }>, void, any>;
        };
        features: {
            frequency: BitFlag;
            lighting: BitFlag;
            onOff: BitFlag;
        };
        id: Branded<8, "ClusterId">;
        name: "LevelControl";
        revision: 5;
    }>, AlterationsT>

enable

  • enable<const FlagsT>(flags): WithFlags<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            clusterRevision: Attribute<number, never>;
            currentFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    frequency: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            currentLevel: Attribute<null | number, any>;
            defaultMoveRate: OptionalWritableAttribute<null | number, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                frequency: BitFlag;
                lighting: BitFlag;
                onOff: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maxFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    frequency: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            maxLevel: OptionalAttribute<number, any>;
            minFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    frequency: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minLevel: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    lighting: boolean;
                }];
            };
            offTransitionTime: OptionalWritableAttribute<null | number, any>;
            onLevel: WritableAttribute<null | number, any>;
            onOffTransitionTime: OptionalWritableAttribute<number, any>;
            onTransitionTime: OptionalWritableAttribute<null | number, any>;
            options: WritableAttribute<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: BitFlag;
                executeIfOff: BitFlag;
            }>, any>;
            remainingTime: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lighting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            startUpCurrentLevel: WritableAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lighting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            move: Command<TypeFromFields<{
                moveMode: FieldType<LevelControl.MoveMode>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                rate: FieldType<null | number>;
            }>, void, any>;
            moveToClosestFrequency: Command<TypeFromFields<{
                frequency: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    frequency: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            moveToLevel: Command<TypeFromFields<{
                level: FieldType<number>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                transitionTime: FieldType<null | number>;
            }>, void, any>;
            moveToLevelWithOnOff: Command<TypeFromFields<{
                level: FieldType<number>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                transitionTime: FieldType<null | number>;
            }>, void, any>;
            moveWithOnOff: Command<TypeFromFields<{
                moveMode: FieldType<LevelControl.MoveMode>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                rate: FieldType<null | number>;
            }>, void, any>;
            step: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                stepMode: FieldType<LevelControl.StepMode>;
                stepSize: FieldType<number>;
                transitionTime: FieldType<null | number>;
            }>, void, any>;
            stepWithOnOff: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                stepMode: FieldType<LevelControl.StepMode>;
                stepSize: FieldType<number>;
                transitionTime: FieldType<null | number>;
            }>, void, any>;
            stop: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
            }>, void, any>;
            stopWithOnOff: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
            }>, void, any>;
        };
        features: {
            frequency: BitFlag;
            lighting: BitFlag;
            onOff: BitFlag;
        };
        id: Branded<8, "ClusterId">;
        name: "LevelControl";
        revision: 5;
    }>, FlagsT>

  • Modify elements using ElementModifier.enable.

    Type Parameters

    • const FlagsT extends ElementFlags<Of<{
          attributes: {
              acceptedCommandList: Attribute<CommandId[], never>;
              attributeList: Attribute<AttributeId[], never>;
              clusterRevision: Attribute<number, never>;
              currentFrequency: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      frequency: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              currentLevel: Attribute<null | number, any>;
              defaultMoveRate: OptionalWritableAttribute<null | number, any>;
              featureMap: Attribute<TypeFromPartialBitSchema<{
                  frequency: BitFlag;
                  lighting: BitFlag;
                  onOff: BitFlag;
              }>, never>;
              generatedCommandList: Attribute<CommandId[], never>;
              maxFrequency: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      frequency: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              maxLevel: OptionalAttribute<number, any>;
              minFrequency: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      frequency: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              minLevel: OptionalAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      lighting: boolean;
                  }];
              };
              offTransitionTime: OptionalWritableAttribute<null | number, any>;
              onLevel: WritableAttribute<null | number, any>;
              onOffTransitionTime: OptionalWritableAttribute<number, any>;
              onTransitionTime: OptionalWritableAttribute<null | number, any>;
              options: WritableAttribute<TypeFromPartialBitSchema<{
                  coupleColorTempToLevel: BitFlag;
                  executeIfOff: BitFlag;
              }>, any>;
              remainingTime: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      lighting: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              startUpCurrentLevel: WritableAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      lighting: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          commands: {
              move: Command<TypeFromFields<{
                  moveMode: FieldType<LevelControl.MoveMode>;
                  optionsMask: FieldType<TypeFromPartialBitSchema<{
                      coupleColorTempToLevel: BitFlag;
                      executeIfOff: BitFlag;
                  }>>;
                  optionsOverride: FieldType<TypeFromPartialBitSchema<{
                      coupleColorTempToLevel: BitFlag;
                      executeIfOff: BitFlag;
                  }>>;
                  rate: FieldType<null | number>;
              }>, void, any>;
              moveToClosestFrequency: Command<TypeFromFields<{
                  frequency: FieldType<number>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      frequency: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              moveToLevel: Command<TypeFromFields<{
                  level: FieldType<number>;
                  optionsMask: FieldType<TypeFromPartialBitSchema<{
                      coupleColorTempToLevel: BitFlag;
                      executeIfOff: BitFlag;
                  }>>;
                  optionsOverride: FieldType<TypeFromPartialBitSchema<{
                      coupleColorTempToLevel: BitFlag;
                      executeIfOff: BitFlag;
                  }>>;
                  transitionTime: FieldType<null | number>;
              }>, void, any>;
              moveToLevelWithOnOff: Command<TypeFromFields<{
                  level: FieldType<number>;
                  optionsMask: FieldType<TypeFromPartialBitSchema<{
                      coupleColorTempToLevel: BitFlag;
                      executeIfOff: BitFlag;
                  }>>;
                  optionsOverride: FieldType<TypeFromPartialBitSchema<{
                      coupleColorTempToLevel: BitFlag;
                      executeIfOff: BitFlag;
                  }>>;
                  transitionTime: FieldType<null | number>;
              }>, void, any>;
              moveWithOnOff: Command<TypeFromFields<{
                  moveMode: FieldType<LevelControl.MoveMode>;
                  optionsMask: FieldType<TypeFromPartialBitSchema<{
                      coupleColorTempToLevel: BitFlag;
                      executeIfOff: BitFlag;
                  }>>;
                  optionsOverride: FieldType<TypeFromPartialBitSchema<{
                      coupleColorTempToLevel: BitFlag;
                      executeIfOff: BitFlag;
                  }>>;
                  rate: FieldType<null | number>;
              }>, void, any>;
              step: Command<TypeFromFields<{
                  optionsMask: FieldType<TypeFromPartialBitSchema<{
                      coupleColorTempToLevel: BitFlag;
                      executeIfOff: BitFlag;
                  }>>;
                  optionsOverride: FieldType<TypeFromPartialBitSchema<{
                      coupleColorTempToLevel: BitFlag;
                      executeIfOff: BitFlag;
                  }>>;
                  stepMode: FieldType<LevelControl.StepMode>;
                  stepSize: FieldType<number>;
                  transitionTime: FieldType<null | number>;
              }>, void, any>;
              stepWithOnOff: Command<TypeFromFields<{
                  optionsMask: FieldType<TypeFromPartialBitSchema<{
                      coupleColorTempToLevel: BitFlag;
                      executeIfOff: BitFlag;
                  }>>;
                  optionsOverride: FieldType<TypeFromPartialBitSchema<{
                      coupleColorTempToLevel: BitFlag;
                      executeIfOff: BitFlag;
                  }>>;
                  stepMode: FieldType<LevelControl.StepMode>;
                  stepSize: FieldType<number>;
                  transitionTime: FieldType<null | number>;
              }>, void, any>;
              stop: Command<TypeFromFields<{
                  optionsMask: FieldType<TypeFromPartialBitSchema<{
                      coupleColorTempToLevel: BitFlag;
                      executeIfOff: BitFlag;
                  }>>;
                  optionsOverride: FieldType<TypeFromPartialBitSchema<{
                      coupleColorTempToLevel: BitFlag;
                      executeIfOff: BitFlag;
                  }>>;
              }>, void, any>;
              stopWithOnOff: Command<TypeFromFields<{
                  optionsMask: FieldType<TypeFromPartialBitSchema<{
                      coupleColorTempToLevel: BitFlag;
                      executeIfOff: BitFlag;
                  }>>;
                  optionsOverride: FieldType<TypeFromPartialBitSchema<{
                      coupleColorTempToLevel: BitFlag;
                      executeIfOff: BitFlag;
                  }>>;
              }>, void, any>;
          };
          features: {
              frequency: BitFlag;
              lighting: BitFlag;
              onOff: BitFlag;
          };
          id: Branded<8, "ClusterId">;
          name: "LevelControl";
          revision: 5;
      }>>

    Parameters

    Returns WithFlags<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            clusterRevision: Attribute<number, never>;
            currentFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    frequency: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            currentLevel: Attribute<null | number, any>;
            defaultMoveRate: OptionalWritableAttribute<null | number, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                frequency: BitFlag;
                lighting: BitFlag;
                onOff: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maxFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    frequency: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            maxLevel: OptionalAttribute<number, any>;
            minFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    frequency: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minLevel: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    lighting: boolean;
                }];
            };
            offTransitionTime: OptionalWritableAttribute<null | number, any>;
            onLevel: WritableAttribute<null | number, any>;
            onOffTransitionTime: OptionalWritableAttribute<number, any>;
            onTransitionTime: OptionalWritableAttribute<null | number, any>;
            options: WritableAttribute<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: BitFlag;
                executeIfOff: BitFlag;
            }>, any>;
            remainingTime: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lighting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            startUpCurrentLevel: WritableAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lighting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            move: Command<TypeFromFields<{
                moveMode: FieldType<LevelControl.MoveMode>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                rate: FieldType<null | number>;
            }>, void, any>;
            moveToClosestFrequency: Command<TypeFromFields<{
                frequency: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    frequency: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            moveToLevel: Command<TypeFromFields<{
                level: FieldType<number>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                transitionTime: FieldType<null | number>;
            }>, void, any>;
            moveToLevelWithOnOff: Command<TypeFromFields<{
                level: FieldType<number>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                transitionTime: FieldType<null | number>;
            }>, void, any>;
            moveWithOnOff: Command<TypeFromFields<{
                moveMode: FieldType<LevelControl.MoveMode>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                rate: FieldType<null | number>;
            }>, void, any>;
            step: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                stepMode: FieldType<LevelControl.StepMode>;
                stepSize: FieldType<number>;
                transitionTime: FieldType<null | number>;
            }>, void, any>;
            stepWithOnOff: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                stepMode: FieldType<LevelControl.StepMode>;
                stepSize: FieldType<number>;
                transitionTime: FieldType<null | number>;
            }>, void, any>;
            stop: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
            }>, void, any>;
            stopWithOnOff: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
            }>, void, any>;
        };
        features: {
            frequency: BitFlag;
            lighting: BitFlag;
            onOff: BitFlag;
        };
        id: Branded<8, "ClusterId">;
        name: "LevelControl";
        revision: 5;
    }>, FlagsT>

set

  • set<const ValuesT>(values): WithValues<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            clusterRevision: Attribute<number, never>;
            currentFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    frequency: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            currentLevel: Attribute<null | number, any>;
            defaultMoveRate: OptionalWritableAttribute<null | number, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                frequency: BitFlag;
                lighting: BitFlag;
                onOff: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maxFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    frequency: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            maxLevel: OptionalAttribute<number, any>;
            minFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    frequency: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minLevel: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    lighting: boolean;
                }];
            };
            offTransitionTime: OptionalWritableAttribute<null | number, any>;
            onLevel: WritableAttribute<null | number, any>;
            onOffTransitionTime: OptionalWritableAttribute<number, any>;
            onTransitionTime: OptionalWritableAttribute<null | number, any>;
            options: WritableAttribute<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: BitFlag;
                executeIfOff: BitFlag;
            }>, any>;
            remainingTime: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lighting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            startUpCurrentLevel: WritableAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lighting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            move: Command<TypeFromFields<{
                moveMode: FieldType<LevelControl.MoveMode>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                rate: FieldType<null | number>;
            }>, void, any>;
            moveToClosestFrequency: Command<TypeFromFields<{
                frequency: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    frequency: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            moveToLevel: Command<TypeFromFields<{
                level: FieldType<number>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                transitionTime: FieldType<null | number>;
            }>, void, any>;
            moveToLevelWithOnOff: Command<TypeFromFields<{
                level: FieldType<number>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                transitionTime: FieldType<null | number>;
            }>, void, any>;
            moveWithOnOff: Command<TypeFromFields<{
                moveMode: FieldType<LevelControl.MoveMode>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                rate: FieldType<null | number>;
            }>, void, any>;
            step: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                stepMode: FieldType<LevelControl.StepMode>;
                stepSize: FieldType<number>;
                transitionTime: FieldType<null | number>;
            }>, void, any>;
            stepWithOnOff: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                stepMode: FieldType<LevelControl.StepMode>;
                stepSize: FieldType<number>;
                transitionTime: FieldType<null | number>;
            }>, void, any>;
            stop: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
            }>, void, any>;
            stopWithOnOff: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
            }>, void, any>;
        };
        features: {
            frequency: BitFlag;
            lighting: BitFlag;
            onOff: BitFlag;
        };
        id: Branded<8, "ClusterId">;
        name: "LevelControl";
        revision: 5;
    }>, ValuesT>

  • Modify elements using ElementModifier.set.

    Type Parameters

    • const ValuesT extends {
          currentFrequency?: number;
          currentLevel: null | number;
          defaultMoveRate?: null | number;
          maxFrequency?: number;
          maxLevel?: number;
          minFrequency?: number;
          minLevel?: number;
          offTransitionTime?: null | number;
          onLevel: null | number;
          onOffTransitionTime?: number;
          onTransitionTime?: null | number;
          options: {
              coupleColorTempToLevel?: boolean;
              executeIfOff?: boolean;
          };
          remainingTime?: number;
          startUpCurrentLevel?: null | number;
      }

    Parameters

    Returns WithValues<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            clusterRevision: Attribute<number, never>;
            currentFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    frequency: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            currentLevel: Attribute<null | number, any>;
            defaultMoveRate: OptionalWritableAttribute<null | number, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                frequency: BitFlag;
                lighting: BitFlag;
                onOff: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maxFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    frequency: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            maxLevel: OptionalAttribute<number, any>;
            minFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    frequency: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minLevel: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    lighting: boolean;
                }];
            };
            offTransitionTime: OptionalWritableAttribute<null | number, any>;
            onLevel: WritableAttribute<null | number, any>;
            onOffTransitionTime: OptionalWritableAttribute<number, any>;
            onTransitionTime: OptionalWritableAttribute<null | number, any>;
            options: WritableAttribute<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: BitFlag;
                executeIfOff: BitFlag;
            }>, any>;
            remainingTime: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lighting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            startUpCurrentLevel: WritableAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lighting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            move: Command<TypeFromFields<{
                moveMode: FieldType<LevelControl.MoveMode>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                rate: FieldType<null | number>;
            }>, void, any>;
            moveToClosestFrequency: Command<TypeFromFields<{
                frequency: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    frequency: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            moveToLevel: Command<TypeFromFields<{
                level: FieldType<number>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                transitionTime: FieldType<null | number>;
            }>, void, any>;
            moveToLevelWithOnOff: Command<TypeFromFields<{
                level: FieldType<number>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                transitionTime: FieldType<null | number>;
            }>, void, any>;
            moveWithOnOff: Command<TypeFromFields<{
                moveMode: FieldType<LevelControl.MoveMode>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                rate: FieldType<null | number>;
            }>, void, any>;
            step: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                stepMode: FieldType<LevelControl.StepMode>;
                stepSize: FieldType<number>;
                transitionTime: FieldType<null | number>;
            }>, void, any>;
            stepWithOnOff: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                stepMode: FieldType<LevelControl.StepMode>;
                stepSize: FieldType<number>;
                transitionTime: FieldType<null | number>;
            }>, void, any>;
            stop: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
            }>, void, any>;
            stopWithOnOff: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
            }>, void, any>;
        };
        features: {
            frequency: BitFlag;
            lighting: BitFlag;
            onOff: BitFlag;
        };
        id: Branded<8, "ClusterId">;
        name: "LevelControl";
        revision: 5;
    }>, ValuesT>

with

  • with<const SelectionT>(...selection): Of<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            clusterRevision: Attribute<number, never>;
            currentFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    frequency: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            currentLevel: Attribute<null | number, any>;
            defaultMoveRate: OptionalWritableAttribute<null | number, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                frequency: BitFlag;
                lighting: BitFlag;
                onOff: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maxFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    frequency: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            maxLevel: OptionalAttribute<number, any>;
            minFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    frequency: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minLevel: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    lighting: boolean;
                }];
            };
            offTransitionTime: OptionalWritableAttribute<null | number, any>;
            onLevel: WritableAttribute<null | number, any>;
            onOffTransitionTime: OptionalWritableAttribute<number, any>;
            onTransitionTime: OptionalWritableAttribute<null | number, any>;
            options: WritableAttribute<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: BitFlag;
                executeIfOff: BitFlag;
            }>, any>;
            remainingTime: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lighting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            startUpCurrentLevel: WritableAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lighting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            move: Command<TypeFromFields<{
                moveMode: FieldType<LevelControl.MoveMode>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                rate: FieldType<null | number>;
            }>, void, any>;
            moveToClosestFrequency: Command<TypeFromFields<{
                frequency: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    frequency: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            moveToLevel: Command<TypeFromFields<{
                level: FieldType<number>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                transitionTime: FieldType<null | number>;
            }>, void, any>;
            moveToLevelWithOnOff: Command<TypeFromFields<{
                level: FieldType<number>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                transitionTime: FieldType<null | number>;
            }>, void, any>;
            moveWithOnOff: Command<TypeFromFields<{
                moveMode: FieldType<LevelControl.MoveMode>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                rate: FieldType<null | number>;
            }>, void, any>;
            step: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                stepMode: FieldType<LevelControl.StepMode>;
                stepSize: FieldType<number>;
                transitionTime: FieldType<null | number>;
            }>, void, any>;
            stepWithOnOff: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                stepMode: FieldType<LevelControl.StepMode>;
                stepSize: FieldType<number>;
                transitionTime: FieldType<null | number>;
            }>, void, any>;
            stop: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
            }>, void, any>;
            stopWithOnOff: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
            }>, void, any>;
        };
        features: {
            frequency: BitFlag;
            lighting: BitFlag;
            onOff: BitFlag;
        };
        id: Branded<8, "ClusterId">;
        name: "LevelControl";
        revision: 5;
    }>, SelectionT>

  • Select features using ClusterComposer.compose.

    Type Parameters

    • const SelectionT extends FeatureSelection<Of<{
          attributes: {
              acceptedCommandList: Attribute<CommandId[], never>;
              attributeList: Attribute<AttributeId[], never>;
              clusterRevision: Attribute<number, never>;
              currentFrequency: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      frequency: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              currentLevel: Attribute<null | number, any>;
              defaultMoveRate: OptionalWritableAttribute<null | number, any>;
              featureMap: Attribute<TypeFromPartialBitSchema<{
                  frequency: BitFlag;
                  lighting: BitFlag;
                  onOff: BitFlag;
              }>, never>;
              generatedCommandList: Attribute<CommandId[], never>;
              maxFrequency: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      frequency: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              maxLevel: OptionalAttribute<number, any>;
              minFrequency: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      frequency: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              minLevel: OptionalAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      lighting: boolean;
                  }];
              };
              offTransitionTime: OptionalWritableAttribute<null | number, any>;
              onLevel: WritableAttribute<null | number, any>;
              onOffTransitionTime: OptionalWritableAttribute<number, any>;
              onTransitionTime: OptionalWritableAttribute<null | number, any>;
              options: WritableAttribute<TypeFromPartialBitSchema<{
                  coupleColorTempToLevel: BitFlag;
                  executeIfOff: BitFlag;
              }>, any>;
              remainingTime: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      lighting: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              startUpCurrentLevel: WritableAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      lighting: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          commands: {
              move: Command<TypeFromFields<{
                  moveMode: FieldType<LevelControl.MoveMode>;
                  optionsMask: FieldType<TypeFromPartialBitSchema<{
                      coupleColorTempToLevel: BitFlag;
                      executeIfOff: BitFlag;
                  }>>;
                  optionsOverride: FieldType<TypeFromPartialBitSchema<{
                      coupleColorTempToLevel: BitFlag;
                      executeIfOff: BitFlag;
                  }>>;
                  rate: FieldType<null | number>;
              }>, void, any>;
              moveToClosestFrequency: Command<TypeFromFields<{
                  frequency: FieldType<number>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      frequency: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              moveToLevel: Command<TypeFromFields<{
                  level: FieldType<number>;
                  optionsMask: FieldType<TypeFromPartialBitSchema<{
                      coupleColorTempToLevel: BitFlag;
                      executeIfOff: BitFlag;
                  }>>;
                  optionsOverride: FieldType<TypeFromPartialBitSchema<{
                      coupleColorTempToLevel: BitFlag;
                      executeIfOff: BitFlag;
                  }>>;
                  transitionTime: FieldType<null | number>;
              }>, void, any>;
              moveToLevelWithOnOff: Command<TypeFromFields<{
                  level: FieldType<number>;
                  optionsMask: FieldType<TypeFromPartialBitSchema<{
                      coupleColorTempToLevel: BitFlag;
                      executeIfOff: BitFlag;
                  }>>;
                  optionsOverride: FieldType<TypeFromPartialBitSchema<{
                      coupleColorTempToLevel: BitFlag;
                      executeIfOff: BitFlag;
                  }>>;
                  transitionTime: FieldType<null | number>;
              }>, void, any>;
              moveWithOnOff: Command<TypeFromFields<{
                  moveMode: FieldType<LevelControl.MoveMode>;
                  optionsMask: FieldType<TypeFromPartialBitSchema<{
                      coupleColorTempToLevel: BitFlag;
                      executeIfOff: BitFlag;
                  }>>;
                  optionsOverride: FieldType<TypeFromPartialBitSchema<{
                      coupleColorTempToLevel: BitFlag;
                      executeIfOff: BitFlag;
                  }>>;
                  rate: FieldType<null | number>;
              }>, void, any>;
              step: Command<TypeFromFields<{
                  optionsMask: FieldType<TypeFromPartialBitSchema<{
                      coupleColorTempToLevel: BitFlag;
                      executeIfOff: BitFlag;
                  }>>;
                  optionsOverride: FieldType<TypeFromPartialBitSchema<{
                      coupleColorTempToLevel: BitFlag;
                      executeIfOff: BitFlag;
                  }>>;
                  stepMode: FieldType<LevelControl.StepMode>;
                  stepSize: FieldType<number>;
                  transitionTime: FieldType<null | number>;
              }>, void, any>;
              stepWithOnOff: Command<TypeFromFields<{
                  optionsMask: FieldType<TypeFromPartialBitSchema<{
                      coupleColorTempToLevel: BitFlag;
                      executeIfOff: BitFlag;
                  }>>;
                  optionsOverride: FieldType<TypeFromPartialBitSchema<{
                      coupleColorTempToLevel: BitFlag;
                      executeIfOff: BitFlag;
                  }>>;
                  stepMode: FieldType<LevelControl.StepMode>;
                  stepSize: FieldType<number>;
                  transitionTime: FieldType<null | number>;
              }>, void, any>;
              stop: Command<TypeFromFields<{
                  optionsMask: FieldType<TypeFromPartialBitSchema<{
                      coupleColorTempToLevel: BitFlag;
                      executeIfOff: BitFlag;
                  }>>;
                  optionsOverride: FieldType<TypeFromPartialBitSchema<{
                      coupleColorTempToLevel: BitFlag;
                      executeIfOff: BitFlag;
                  }>>;
              }>, void, any>;
              stopWithOnOff: Command<TypeFromFields<{
                  optionsMask: FieldType<TypeFromPartialBitSchema<{
                      coupleColorTempToLevel: BitFlag;
                      executeIfOff: BitFlag;
                  }>>;
                  optionsOverride: FieldType<TypeFromPartialBitSchema<{
                      coupleColorTempToLevel: BitFlag;
                      executeIfOff: BitFlag;
                  }>>;
              }>, void, any>;
          };
          features: {
              frequency: BitFlag;
              lighting: BitFlag;
              onOff: BitFlag;
          };
          id: Branded<8, "ClusterId">;
          name: "LevelControl";
          revision: 5;
      }>>

    Parameters

    Returns Of<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            clusterRevision: Attribute<number, never>;
            currentFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    frequency: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            currentLevel: Attribute<null | number, any>;
            defaultMoveRate: OptionalWritableAttribute<null | number, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                frequency: BitFlag;
                lighting: BitFlag;
                onOff: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maxFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    frequency: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            maxLevel: OptionalAttribute<number, any>;
            minFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    frequency: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minLevel: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    lighting: boolean;
                }];
            };
            offTransitionTime: OptionalWritableAttribute<null | number, any>;
            onLevel: WritableAttribute<null | number, any>;
            onOffTransitionTime: OptionalWritableAttribute<number, any>;
            onTransitionTime: OptionalWritableAttribute<null | number, any>;
            options: WritableAttribute<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: BitFlag;
                executeIfOff: BitFlag;
            }>, any>;
            remainingTime: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lighting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            startUpCurrentLevel: WritableAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lighting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            move: Command<TypeFromFields<{
                moveMode: FieldType<LevelControl.MoveMode>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                rate: FieldType<null | number>;
            }>, void, any>;
            moveToClosestFrequency: Command<TypeFromFields<{
                frequency: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    frequency: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            moveToLevel: Command<TypeFromFields<{
                level: FieldType<number>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                transitionTime: FieldType<null | number>;
            }>, void, any>;
            moveToLevelWithOnOff: Command<TypeFromFields<{
                level: FieldType<number>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                transitionTime: FieldType<null | number>;
            }>, void, any>;
            moveWithOnOff: Command<TypeFromFields<{
                moveMode: FieldType<LevelControl.MoveMode>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                rate: FieldType<null | number>;
            }>, void, any>;
            step: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                stepMode: FieldType<LevelControl.StepMode>;
                stepSize: FieldType<number>;
                transitionTime: FieldType<null | number>;
            }>, void, any>;
            stepWithOnOff: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                stepMode: FieldType<LevelControl.StepMode>;
                stepSize: FieldType<number>;
                transitionTime: FieldType<null | number>;
            }>, void, any>;
            stop: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
            }>, void, any>;
            stopWithOnOff: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    coupleColorTempToLevel: BitFlag;
                    executeIfOff: BitFlag;
                }>>;
            }>, void, any>;
        };
        features: {
            frequency: BitFlag;
            lighting: BitFlag;
            onOff: BitFlag;
        };
        id: Branded<8, "ClusterId">;
        name: "LevelControl";
        revision: 5;
    }>, SelectionT>

Settings

Member Visibility

On This Page

Properties
Methods