Interface Complete

An identity type.

You can't do:

interface Foo extends typeof Bar {}

But you can do:

interface Foo extends Identity<typeof Bar> {}

Without this type you'd have to do:

interface FooType = typeof Bar;
interface Foo extends FooType {};

We have to do this a lot because we generate complex objects with detailed type information. When exported, TS (as of 5.2) inlines the type of these objects in declarations which makes our declarations massive. To avoid this we create an interface from the type then cast to the interface for export.

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

Hierarchy (view full)

Identity<typeof PulseWidthModulation.CompleteInstance>
- Complete

Index

Properties

attributes base commands events extensions features id name revision supportedFeatures unknown

Methods

alter enable set with

Properties

attributes

attributes: Merge<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;
}>>, GlobalAttributes<{
    frequency: BitFlag;
    lighting: BitFlag;
    onOff: BitFlag;
}>>

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>;
}

events

events: {}

extensions

extensions: undefined

features

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

id

id: Branded<28, "ClusterId">

name

revision

supportedFeatures

supportedFeatures: {}

unknown

Methods

alter

alter<const AlterationsT>(alterations): WithAlterations<Of<{
    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: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            currentLevel: Attribute<null | number, any>;
            defaultMoveRate: OptionalWritableAttribute<null | number, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                frequency: ...;
                lighting: ...;
                onOff: ...;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maxFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            maxLevel: OptionalAttribute<number, any>;
            minFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            minLevel: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            offTransitionTime: OptionalWritableAttribute<null | number, any>;
            onLevel: WritableAttribute<null | number, any>;
            onOffTransitionTime: OptionalWritableAttribute<number, any>;
            onTransitionTime: OptionalWritableAttribute<null | number, any>;
            options: WritableAttribute<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: ...;
                executeIfOff: ...;
            }>, any>;
            remainingTime: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            startUpCurrentLevel: WritableAttribute<(...) | (...), any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
        };
        commands: {
            move: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            moveToClosestFrequency: Command<TypeFromFields<(...)>, void, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            moveToLevel: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveToLevelWithOnOff: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveWithOnOff: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            step: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stepWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stop: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
            stopWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
        };
        features: {
            frequency: BitFlag;
            lighting: BitFlag;
            onOff: BitFlag;
        };
        id: Branded<8, "ClusterId">;
        name: "LevelControl";
        revision: 5;
    }>, AlterationsT>);
    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>;
    };
    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: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            currentLevel: Attribute<null | number, any>;
            defaultMoveRate: OptionalWritableAttribute<null | number, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                frequency: ...;
                lighting: ...;
                onOff: ...;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maxFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            maxLevel: OptionalAttribute<number, any>;
            minFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            minLevel: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            offTransitionTime: OptionalWritableAttribute<null | number, any>;
            onLevel: WritableAttribute<null | number, any>;
            onOffTransitionTime: OptionalWritableAttribute<number, any>;
            onTransitionTime: OptionalWritableAttribute<null | number, any>;
            options: WritableAttribute<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: ...;
                executeIfOff: ...;
            }>, any>;
            remainingTime: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            startUpCurrentLevel: WritableAttribute<(...) | (...), any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
        };
        commands: {
            move: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            moveToClosestFrequency: Command<TypeFromFields<(...)>, void, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            moveToLevel: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveToLevelWithOnOff: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveWithOnOff: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            step: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stepWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stop: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
            stopWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
        };
        features: {
            frequency: BitFlag;
            lighting: BitFlag;
            onOff: BitFlag;
        };
        id: Branded<8, "ClusterId">;
        name: "LevelControl";
        revision: 5;
    }>, FlagsT>);
    events: {};
    extensions: undefined;
    features: {
        frequency: BitFlag;
        lighting: BitFlag;
        onOff: BitFlag;
    };
    id: 28;
    name: "PulseWidthModulation";
    revision: 5;
    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: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            currentLevel: Attribute<null | number, any>;
            defaultMoveRate: OptionalWritableAttribute<null | number, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                frequency: ...;
                lighting: ...;
                onOff: ...;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maxFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            maxLevel: OptionalAttribute<number, any>;
            minFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            minLevel: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            offTransitionTime: OptionalWritableAttribute<null | number, any>;
            onLevel: WritableAttribute<null | number, any>;
            onOffTransitionTime: OptionalWritableAttribute<number, any>;
            onTransitionTime: OptionalWritableAttribute<null | number, any>;
            options: WritableAttribute<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: ...;
                executeIfOff: ...;
            }>, any>;
            remainingTime: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            startUpCurrentLevel: WritableAttribute<(...) | (...), any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
        };
        commands: {
            move: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            moveToClosestFrequency: Command<TypeFromFields<(...)>, void, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            moveToLevel: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveToLevelWithOnOff: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveWithOnOff: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            step: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stepWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stop: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
            stopWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
        };
        features: {
            frequency: BitFlag;
            lighting: BitFlag;
            onOff: BitFlag;
        };
        id: Branded<8, "ClusterId">;
        name: "LevelControl";
        revision: 5;
    }>, ValuesT>);
    supportedFeatures: {};
    unknown: false;
    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: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            currentLevel: Attribute<null | number, any>;
            defaultMoveRate: OptionalWritableAttribute<null | number, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                frequency: ...;
                lighting: ...;
                onOff: ...;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maxFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            maxLevel: OptionalAttribute<number, any>;
            minFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            minLevel: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            offTransitionTime: OptionalWritableAttribute<null | number, any>;
            onLevel: WritableAttribute<null | number, any>;
            onOffTransitionTime: OptionalWritableAttribute<number, any>;
            onTransitionTime: OptionalWritableAttribute<null | number, any>;
            options: WritableAttribute<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: ...;
                executeIfOff: ...;
            }>, any>;
            remainingTime: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            startUpCurrentLevel: WritableAttribute<(...) | (...), any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
        };
        commands: {
            move: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            moveToClosestFrequency: Command<TypeFromFields<(...)>, void, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            moveToLevel: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveToLevelWithOnOff: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveWithOnOff: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            step: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stepWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stop: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
            stopWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
        };
        features: {
            frequency: BitFlag;
            lighting: BitFlag;
            onOff: BitFlag;
        };
        id: Branded<8, "ClusterId">;
        name: "LevelControl";
        revision: 5;
    }>, SelectionT>);
}>, AlterationsT>
Modify elements using ElementModifier.alter.
Type Parameters
- const AlterationsT extends Alterations<Of<{
      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: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              currentLevel: Attribute<null | number, any>;
              defaultMoveRate: OptionalWritableAttribute<null | number, any>;
              featureMap: Attribute<TypeFromPartialBitSchema<{
                  frequency: ...;
                  lighting: ...;
                  onOff: ...;
              }>, never>;
              generatedCommandList: Attribute<CommandId[], never>;
              maxFrequency: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              maxLevel: OptionalAttribute<number, any>;
              minFrequency: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              minLevel: OptionalAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              offTransitionTime: OptionalWritableAttribute<null | number, any>;
              onLevel: WritableAttribute<null | number, any>;
              onOffTransitionTime: OptionalWritableAttribute<number, any>;
              onTransitionTime: OptionalWritableAttribute<null | number, any>;
              options: WritableAttribute<TypeFromPartialBitSchema<{
                  coupleColorTempToLevel: ...;
                  executeIfOff: ...;
              }>, any>;
              remainingTime: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              startUpCurrentLevel: WritableAttribute<(...) | (...), any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
          };
          commands: {
              move: Command<TypeFromFields<{
                  moveMode: ...;
                  optionsMask: ...;
                  optionsOverride: ...;
                  rate: ...;
              }>, void, any>;
              moveToClosestFrequency: Command<TypeFromFields<(...)>, void, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              moveToLevel: Command<TypeFromFields<{
                  level: ...;
                  optionsMask: ...;
                  optionsOverride: ...;
                  transitionTime: ...;
              }>, void, any>;
              moveToLevelWithOnOff: Command<TypeFromFields<{
                  level: ...;
                  optionsMask: ...;
                  optionsOverride: ...;
                  transitionTime: ...;
              }>, void, any>;
              moveWithOnOff: Command<TypeFromFields<{
                  moveMode: ...;
                  optionsMask: ...;
                  optionsOverride: ...;
                  rate: ...;
              }>, void, any>;
              step: Command<TypeFromFields<{
                  optionsMask: ...;
                  optionsOverride: ...;
                  stepMode: ...;
                  stepSize: ...;
                  transitionTime: ...;
              }>, void, any>;
              stepWithOnOff: Command<TypeFromFields<{
                  optionsMask: ...;
                  optionsOverride: ...;
                  stepMode: ...;
                  stepSize: ...;
                  transitionTime: ...;
              }>, void, any>;
              stop: Command<TypeFromFields<{
                  optionsMask: ...;
                  optionsOverride: ...;
              }>, void, any>;
              stopWithOnOff: Command<TypeFromFields<{
                  optionsMask: ...;
                  optionsOverride: ...;
              }>, void, any>;
          };
          features: {
              frequency: BitFlag;
              lighting: BitFlag;
              onOff: BitFlag;
          };
          id: Branded<8, "ClusterId">;
          name: "LevelControl";
          revision: 5;
      }>, AlterationsT>);
      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>;
      };
      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: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              currentLevel: Attribute<null | number, any>;
              defaultMoveRate: OptionalWritableAttribute<null | number, any>;
              featureMap: Attribute<TypeFromPartialBitSchema<{
                  frequency: ...;
                  lighting: ...;
                  onOff: ...;
              }>, never>;
              generatedCommandList: Attribute<CommandId[], never>;
              maxFrequency: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              maxLevel: OptionalAttribute<number, any>;
              minFrequency: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              minLevel: OptionalAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              offTransitionTime: OptionalWritableAttribute<null | number, any>;
              onLevel: WritableAttribute<null | number, any>;
              onOffTransitionTime: OptionalWritableAttribute<number, any>;
              onTransitionTime: OptionalWritableAttribute<null | number, any>;
              options: WritableAttribute<TypeFromPartialBitSchema<{
                  coupleColorTempToLevel: ...;
                  executeIfOff: ...;
              }>, any>;
              remainingTime: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              startUpCurrentLevel: WritableAttribute<(...) | (...), any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
          };
          commands: {
              move: Command<TypeFromFields<{
                  moveMode: ...;
                  optionsMask: ...;
                  optionsOverride: ...;
                  rate: ...;
              }>, void, any>;
              moveToClosestFrequency: Command<TypeFromFields<(...)>, void, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              moveToLevel: Command<TypeFromFields<{
                  level: ...;
                  optionsMask: ...;
                  optionsOverride: ...;
                  transitionTime: ...;
              }>, void, any>;
              moveToLevelWithOnOff: Command<TypeFromFields<{
                  level: ...;
                  optionsMask: ...;
                  optionsOverride: ...;
                  transitionTime: ...;
              }>, void, any>;
              moveWithOnOff: Command<TypeFromFields<{
                  moveMode: ...;
                  optionsMask: ...;
                  optionsOverride: ...;
                  rate: ...;
              }>, void, any>;
              step: Command<TypeFromFields<{
                  optionsMask: ...;
                  optionsOverride: ...;
                  stepMode: ...;
                  stepSize: ...;
                  transitionTime: ...;
              }>, void, any>;
              stepWithOnOff: Command<TypeFromFields<{
                  optionsMask: ...;
                  optionsOverride: ...;
                  stepMode: ...;
                  stepSize: ...;
                  transitionTime: ...;
              }>, void, any>;
              stop: Command<TypeFromFields<{
                  optionsMask: ...;
                  optionsOverride: ...;
              }>, void, any>;
              stopWithOnOff: Command<TypeFromFields<{
                  optionsMask: ...;
                  optionsOverride: ...;
              }>, void, any>;
          };
          features: {
              frequency: BitFlag;
              lighting: BitFlag;
              onOff: BitFlag;
          };
          id: Branded<8, "ClusterId">;
          name: "LevelControl";
          revision: 5;
      }>, FlagsT>);
      events: {};
      extensions: undefined;
      features: {
          frequency: BitFlag;
          lighting: BitFlag;
          onOff: BitFlag;
      };
      id: 28;
      name: "PulseWidthModulation";
      revision: 5;
      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: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              currentLevel: Attribute<null | number, any>;
              defaultMoveRate: OptionalWritableAttribute<null | number, any>;
              featureMap: Attribute<TypeFromPartialBitSchema<{
                  frequency: ...;
                  lighting: ...;
                  onOff: ...;
              }>, never>;
              generatedCommandList: Attribute<CommandId[], never>;
              maxFrequency: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              maxLevel: OptionalAttribute<number, any>;
              minFrequency: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              minLevel: OptionalAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              offTransitionTime: OptionalWritableAttribute<null | number, any>;
              onLevel: WritableAttribute<null | number, any>;
              onOffTransitionTime: OptionalWritableAttribute<number, any>;
              onTransitionTime: OptionalWritableAttribute<null | number, any>;
              options: WritableAttribute<TypeFromPartialBitSchema<{
                  coupleColorTempToLevel: ...;
                  executeIfOff: ...;
              }>, any>;
              remainingTime: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              startUpCurrentLevel: WritableAttribute<(...) | (...), any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
          };
          commands: {
              move: Command<TypeFromFields<{
                  moveMode: ...;
                  optionsMask: ...;
                  optionsOverride: ...;
                  rate: ...;
              }>, void, any>;
              moveToClosestFrequency: Command<TypeFromFields<(...)>, void, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              moveToLevel: Command<TypeFromFields<{
                  level: ...;
                  optionsMask: ...;
                  optionsOverride: ...;
                  transitionTime: ...;
              }>, void, any>;
              moveToLevelWithOnOff: Command<TypeFromFields<{
                  level: ...;
                  optionsMask: ...;
                  optionsOverride: ...;
                  transitionTime: ...;
              }>, void, any>;
              moveWithOnOff: Command<TypeFromFields<{
                  moveMode: ...;
                  optionsMask: ...;
                  optionsOverride: ...;
                  rate: ...;
              }>, void, any>;
              step: Command<TypeFromFields<{
                  optionsMask: ...;
                  optionsOverride: ...;
                  stepMode: ...;
                  stepSize: ...;
                  transitionTime: ...;
              }>, void, any>;
              stepWithOnOff: Command<TypeFromFields<{
                  optionsMask: ...;
                  optionsOverride: ...;
                  stepMode: ...;
                  stepSize: ...;
                  transitionTime: ...;
              }>, void, any>;
              stop: Command<TypeFromFields<{
                  optionsMask: ...;
                  optionsOverride: ...;
              }>, void, any>;
              stopWithOnOff: Command<TypeFromFields<{
                  optionsMask: ...;
                  optionsOverride: ...;
              }>, void, any>;
          };
          features: {
              frequency: BitFlag;
              lighting: BitFlag;
              onOff: BitFlag;
          };
          id: Branded<8, "ClusterId">;
          name: "LevelControl";
          revision: 5;
      }>, ValuesT>);
      supportedFeatures: {};
      unknown: false;
      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: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              currentLevel: Attribute<null | number, any>;
              defaultMoveRate: OptionalWritableAttribute<null | number, any>;
              featureMap: Attribute<TypeFromPartialBitSchema<{
                  frequency: ...;
                  lighting: ...;
                  onOff: ...;
              }>, never>;
              generatedCommandList: Attribute<CommandId[], never>;
              maxFrequency: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              maxLevel: OptionalAttribute<number, any>;
              minFrequency: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              minLevel: OptionalAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              offTransitionTime: OptionalWritableAttribute<null | number, any>;
              onLevel: WritableAttribute<null | number, any>;
              onOffTransitionTime: OptionalWritableAttribute<number, any>;
              onTransitionTime: OptionalWritableAttribute<null | number, any>;
              options: WritableAttribute<TypeFromPartialBitSchema<{
                  coupleColorTempToLevel: ...;
                  executeIfOff: ...;
              }>, any>;
              remainingTime: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              startUpCurrentLevel: WritableAttribute<(...) | (...), any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
          };
          commands: {
              move: Command<TypeFromFields<{
                  moveMode: ...;
                  optionsMask: ...;
                  optionsOverride: ...;
                  rate: ...;
              }>, void, any>;
              moveToClosestFrequency: Command<TypeFromFields<(...)>, void, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              moveToLevel: Command<TypeFromFields<{
                  level: ...;
                  optionsMask: ...;
                  optionsOverride: ...;
                  transitionTime: ...;
              }>, void, any>;
              moveToLevelWithOnOff: Command<TypeFromFields<{
                  level: ...;
                  optionsMask: ...;
                  optionsOverride: ...;
                  transitionTime: ...;
              }>, void, any>;
              moveWithOnOff: Command<TypeFromFields<{
                  moveMode: ...;
                  optionsMask: ...;
                  optionsOverride: ...;
                  rate: ...;
              }>, void, any>;
              step: Command<TypeFromFields<{
                  optionsMask: ...;
                  optionsOverride: ...;
                  stepMode: ...;
                  stepSize: ...;
                  transitionTime: ...;
              }>, void, any>;
              stepWithOnOff: Command<TypeFromFields<{
                  optionsMask: ...;
                  optionsOverride: ...;
                  stepMode: ...;
                  stepSize: ...;
                  transitionTime: ...;
              }>, void, any>;
              stop: Command<TypeFromFields<{
                  optionsMask: ...;
                  optionsOverride: ...;
              }>, void, any>;
              stopWithOnOff: Command<TypeFromFields<{
                  optionsMask: ...;
                  optionsOverride: ...;
              }>, void, any>;
          };
          features: {
              frequency: BitFlag;
              lighting: BitFlag;
              onOff: BitFlag;
          };
          id: Branded<8, "ClusterId">;
          name: "LevelControl";
          revision: 5;
      }>, SelectionT>);
  }>>
Parameters
- alterations: AlterationsT
Returns WithAlterations<Of<{
    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: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            currentLevel: Attribute<null | number, any>;
            defaultMoveRate: OptionalWritableAttribute<null | number, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                frequency: ...;
                lighting: ...;
                onOff: ...;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maxFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            maxLevel: OptionalAttribute<number, any>;
            minFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            minLevel: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            offTransitionTime: OptionalWritableAttribute<null | number, any>;
            onLevel: WritableAttribute<null | number, any>;
            onOffTransitionTime: OptionalWritableAttribute<number, any>;
            onTransitionTime: OptionalWritableAttribute<null | number, any>;
            options: WritableAttribute<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: ...;
                executeIfOff: ...;
            }>, any>;
            remainingTime: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            startUpCurrentLevel: WritableAttribute<(...) | (...), any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
        };
        commands: {
            move: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            moveToClosestFrequency: Command<TypeFromFields<(...)>, void, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            moveToLevel: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveToLevelWithOnOff: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveWithOnOff: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            step: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stepWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stop: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
            stopWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
        };
        features: {
            frequency: BitFlag;
            lighting: BitFlag;
            onOff: BitFlag;
        };
        id: Branded<8, "ClusterId">;
        name: "LevelControl";
        revision: 5;
    }>, AlterationsT>);
    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>;
    };
    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: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            currentLevel: Attribute<null | number, any>;
            defaultMoveRate: OptionalWritableAttribute<null | number, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                frequency: ...;
                lighting: ...;
                onOff: ...;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maxFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            maxLevel: OptionalAttribute<number, any>;
            minFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            minLevel: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            offTransitionTime: OptionalWritableAttribute<null | number, any>;
            onLevel: WritableAttribute<null | number, any>;
            onOffTransitionTime: OptionalWritableAttribute<number, any>;
            onTransitionTime: OptionalWritableAttribute<null | number, any>;
            options: WritableAttribute<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: ...;
                executeIfOff: ...;
            }>, any>;
            remainingTime: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            startUpCurrentLevel: WritableAttribute<(...) | (...), any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
        };
        commands: {
            move: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            moveToClosestFrequency: Command<TypeFromFields<(...)>, void, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            moveToLevel: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveToLevelWithOnOff: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveWithOnOff: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            step: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stepWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stop: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
            stopWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
        };
        features: {
            frequency: BitFlag;
            lighting: BitFlag;
            onOff: BitFlag;
        };
        id: Branded<8, "ClusterId">;
        name: "LevelControl";
        revision: 5;
    }>, FlagsT>);
    events: {};
    extensions: undefined;
    features: {
        frequency: BitFlag;
        lighting: BitFlag;
        onOff: BitFlag;
    };
    id: 28;
    name: "PulseWidthModulation";
    revision: 5;
    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: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            currentLevel: Attribute<null | number, any>;
            defaultMoveRate: OptionalWritableAttribute<null | number, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                frequency: ...;
                lighting: ...;
                onOff: ...;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maxFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            maxLevel: OptionalAttribute<number, any>;
            minFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            minLevel: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            offTransitionTime: OptionalWritableAttribute<null | number, any>;
            onLevel: WritableAttribute<null | number, any>;
            onOffTransitionTime: OptionalWritableAttribute<number, any>;
            onTransitionTime: OptionalWritableAttribute<null | number, any>;
            options: WritableAttribute<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: ...;
                executeIfOff: ...;
            }>, any>;
            remainingTime: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            startUpCurrentLevel: WritableAttribute<(...) | (...), any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
        };
        commands: {
            move: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            moveToClosestFrequency: Command<TypeFromFields<(...)>, void, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            moveToLevel: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveToLevelWithOnOff: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveWithOnOff: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            step: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stepWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stop: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
            stopWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
        };
        features: {
            frequency: BitFlag;
            lighting: BitFlag;
            onOff: BitFlag;
        };
        id: Branded<8, "ClusterId">;
        name: "LevelControl";
        revision: 5;
    }>, ValuesT>);
    supportedFeatures: {};
    unknown: false;
    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: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            currentLevel: Attribute<null | number, any>;
            defaultMoveRate: OptionalWritableAttribute<null | number, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                frequency: ...;
                lighting: ...;
                onOff: ...;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maxFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            maxLevel: OptionalAttribute<number, any>;
            minFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            minLevel: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            offTransitionTime: OptionalWritableAttribute<null | number, any>;
            onLevel: WritableAttribute<null | number, any>;
            onOffTransitionTime: OptionalWritableAttribute<number, any>;
            onTransitionTime: OptionalWritableAttribute<null | number, any>;
            options: WritableAttribute<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: ...;
                executeIfOff: ...;
            }>, any>;
            remainingTime: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            startUpCurrentLevel: WritableAttribute<(...) | (...), any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
        };
        commands: {
            move: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            moveToClosestFrequency: Command<TypeFromFields<(...)>, void, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            moveToLevel: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveToLevelWithOnOff: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveWithOnOff: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            step: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stepWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stop: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
            stopWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
        };
        features: {
            frequency: BitFlag;
            lighting: BitFlag;
            onOff: BitFlag;
        };
        id: Branded<8, "ClusterId">;
        name: "LevelControl";
        revision: 5;
    }>, SelectionT>);
}>, AlterationsT>
Inherited from Identity.alter
- Defined in packages/types/dist/esm/cluster/mutation/MutableCluster.d.ts:37

enable

enable<const FlagsT>(flags): WithFlags<Of<{
    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: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            currentLevel: Attribute<null | number, any>;
            defaultMoveRate: OptionalWritableAttribute<null | number, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                frequency: ...;
                lighting: ...;
                onOff: ...;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maxFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            maxLevel: OptionalAttribute<number, any>;
            minFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            minLevel: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            offTransitionTime: OptionalWritableAttribute<null | number, any>;
            onLevel: WritableAttribute<null | number, any>;
            onOffTransitionTime: OptionalWritableAttribute<number, any>;
            onTransitionTime: OptionalWritableAttribute<null | number, any>;
            options: WritableAttribute<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: ...;
                executeIfOff: ...;
            }>, any>;
            remainingTime: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            startUpCurrentLevel: WritableAttribute<(...) | (...), any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
        };
        commands: {
            move: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            moveToClosestFrequency: Command<TypeFromFields<(...)>, void, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            moveToLevel: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveToLevelWithOnOff: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveWithOnOff: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            step: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stepWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stop: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
            stopWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
        };
        features: {
            frequency: BitFlag;
            lighting: BitFlag;
            onOff: BitFlag;
        };
        id: Branded<8, "ClusterId">;
        name: "LevelControl";
        revision: 5;
    }>, AlterationsT>);
    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>;
    };
    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: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            currentLevel: Attribute<null | number, any>;
            defaultMoveRate: OptionalWritableAttribute<null | number, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                frequency: ...;
                lighting: ...;
                onOff: ...;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maxFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            maxLevel: OptionalAttribute<number, any>;
            minFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            minLevel: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            offTransitionTime: OptionalWritableAttribute<null | number, any>;
            onLevel: WritableAttribute<null | number, any>;
            onOffTransitionTime: OptionalWritableAttribute<number, any>;
            onTransitionTime: OptionalWritableAttribute<null | number, any>;
            options: WritableAttribute<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: ...;
                executeIfOff: ...;
            }>, any>;
            remainingTime: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            startUpCurrentLevel: WritableAttribute<(...) | (...), any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
        };
        commands: {
            move: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            moveToClosestFrequency: Command<TypeFromFields<(...)>, void, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            moveToLevel: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveToLevelWithOnOff: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveWithOnOff: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            step: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stepWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stop: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
            stopWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
        };
        features: {
            frequency: BitFlag;
            lighting: BitFlag;
            onOff: BitFlag;
        };
        id: Branded<8, "ClusterId">;
        name: "LevelControl";
        revision: 5;
    }>, FlagsT>);
    events: {};
    extensions: undefined;
    features: {
        frequency: BitFlag;
        lighting: BitFlag;
        onOff: BitFlag;
    };
    id: 28;
    name: "PulseWidthModulation";
    revision: 5;
    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: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            currentLevel: Attribute<null | number, any>;
            defaultMoveRate: OptionalWritableAttribute<null | number, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                frequency: ...;
                lighting: ...;
                onOff: ...;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maxFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            maxLevel: OptionalAttribute<number, any>;
            minFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            minLevel: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            offTransitionTime: OptionalWritableAttribute<null | number, any>;
            onLevel: WritableAttribute<null | number, any>;
            onOffTransitionTime: OptionalWritableAttribute<number, any>;
            onTransitionTime: OptionalWritableAttribute<null | number, any>;
            options: WritableAttribute<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: ...;
                executeIfOff: ...;
            }>, any>;
            remainingTime: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            startUpCurrentLevel: WritableAttribute<(...) | (...), any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
        };
        commands: {
            move: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            moveToClosestFrequency: Command<TypeFromFields<(...)>, void, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            moveToLevel: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveToLevelWithOnOff: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveWithOnOff: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            step: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stepWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stop: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
            stopWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
        };
        features: {
            frequency: BitFlag;
            lighting: BitFlag;
            onOff: BitFlag;
        };
        id: Branded<8, "ClusterId">;
        name: "LevelControl";
        revision: 5;
    }>, ValuesT>);
    supportedFeatures: {};
    unknown: false;
    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: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            currentLevel: Attribute<null | number, any>;
            defaultMoveRate: OptionalWritableAttribute<null | number, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                frequency: ...;
                lighting: ...;
                onOff: ...;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maxFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            maxLevel: OptionalAttribute<number, any>;
            minFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            minLevel: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            offTransitionTime: OptionalWritableAttribute<null | number, any>;
            onLevel: WritableAttribute<null | number, any>;
            onOffTransitionTime: OptionalWritableAttribute<number, any>;
            onTransitionTime: OptionalWritableAttribute<null | number, any>;
            options: WritableAttribute<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: ...;
                executeIfOff: ...;
            }>, any>;
            remainingTime: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            startUpCurrentLevel: WritableAttribute<(...) | (...), any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
        };
        commands: {
            move: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            moveToClosestFrequency: Command<TypeFromFields<(...)>, void, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            moveToLevel: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveToLevelWithOnOff: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveWithOnOff: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            step: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stepWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stop: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
            stopWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
        };
        features: {
            frequency: BitFlag;
            lighting: BitFlag;
            onOff: BitFlag;
        };
        id: Branded<8, "ClusterId">;
        name: "LevelControl";
        revision: 5;
    }>, SelectionT>);
}>, FlagsT>
Modify elements using ElementModifier.enable.
Type Parameters
- const FlagsT extends ElementFlags<Of<{
      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: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              currentLevel: Attribute<null | number, any>;
              defaultMoveRate: OptionalWritableAttribute<null | number, any>;
              featureMap: Attribute<TypeFromPartialBitSchema<{
                  frequency: ...;
                  lighting: ...;
                  onOff: ...;
              }>, never>;
              generatedCommandList: Attribute<CommandId[], never>;
              maxFrequency: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              maxLevel: OptionalAttribute<number, any>;
              minFrequency: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              minLevel: OptionalAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              offTransitionTime: OptionalWritableAttribute<null | number, any>;
              onLevel: WritableAttribute<null | number, any>;
              onOffTransitionTime: OptionalWritableAttribute<number, any>;
              onTransitionTime: OptionalWritableAttribute<null | number, any>;
              options: WritableAttribute<TypeFromPartialBitSchema<{
                  coupleColorTempToLevel: ...;
                  executeIfOff: ...;
              }>, any>;
              remainingTime: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              startUpCurrentLevel: WritableAttribute<(...) | (...), any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
          };
          commands: {
              move: Command<TypeFromFields<{
                  moveMode: ...;
                  optionsMask: ...;
                  optionsOverride: ...;
                  rate: ...;
              }>, void, any>;
              moveToClosestFrequency: Command<TypeFromFields<(...)>, void, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              moveToLevel: Command<TypeFromFields<{
                  level: ...;
                  optionsMask: ...;
                  optionsOverride: ...;
                  transitionTime: ...;
              }>, void, any>;
              moveToLevelWithOnOff: Command<TypeFromFields<{
                  level: ...;
                  optionsMask: ...;
                  optionsOverride: ...;
                  transitionTime: ...;
              }>, void, any>;
              moveWithOnOff: Command<TypeFromFields<{
                  moveMode: ...;
                  optionsMask: ...;
                  optionsOverride: ...;
                  rate: ...;
              }>, void, any>;
              step: Command<TypeFromFields<{
                  optionsMask: ...;
                  optionsOverride: ...;
                  stepMode: ...;
                  stepSize: ...;
                  transitionTime: ...;
              }>, void, any>;
              stepWithOnOff: Command<TypeFromFields<{
                  optionsMask: ...;
                  optionsOverride: ...;
                  stepMode: ...;
                  stepSize: ...;
                  transitionTime: ...;
              }>, void, any>;
              stop: Command<TypeFromFields<{
                  optionsMask: ...;
                  optionsOverride: ...;
              }>, void, any>;
              stopWithOnOff: Command<TypeFromFields<{
                  optionsMask: ...;
                  optionsOverride: ...;
              }>, void, any>;
          };
          features: {
              frequency: BitFlag;
              lighting: BitFlag;
              onOff: BitFlag;
          };
          id: Branded<8, "ClusterId">;
          name: "LevelControl";
          revision: 5;
      }>, AlterationsT>);
      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>;
      };
      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: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              currentLevel: Attribute<null | number, any>;
              defaultMoveRate: OptionalWritableAttribute<null | number, any>;
              featureMap: Attribute<TypeFromPartialBitSchema<{
                  frequency: ...;
                  lighting: ...;
                  onOff: ...;
              }>, never>;
              generatedCommandList: Attribute<CommandId[], never>;
              maxFrequency: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              maxLevel: OptionalAttribute<number, any>;
              minFrequency: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              minLevel: OptionalAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              offTransitionTime: OptionalWritableAttribute<null | number, any>;
              onLevel: WritableAttribute<null | number, any>;
              onOffTransitionTime: OptionalWritableAttribute<number, any>;
              onTransitionTime: OptionalWritableAttribute<null | number, any>;
              options: WritableAttribute<TypeFromPartialBitSchema<{
                  coupleColorTempToLevel: ...;
                  executeIfOff: ...;
              }>, any>;
              remainingTime: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              startUpCurrentLevel: WritableAttribute<(...) | (...), any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
          };
          commands: {
              move: Command<TypeFromFields<{
                  moveMode: ...;
                  optionsMask: ...;
                  optionsOverride: ...;
                  rate: ...;
              }>, void, any>;
              moveToClosestFrequency: Command<TypeFromFields<(...)>, void, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              moveToLevel: Command<TypeFromFields<{
                  level: ...;
                  optionsMask: ...;
                  optionsOverride: ...;
                  transitionTime: ...;
              }>, void, any>;
              moveToLevelWithOnOff: Command<TypeFromFields<{
                  level: ...;
                  optionsMask: ...;
                  optionsOverride: ...;
                  transitionTime: ...;
              }>, void, any>;
              moveWithOnOff: Command<TypeFromFields<{
                  moveMode: ...;
                  optionsMask: ...;
                  optionsOverride: ...;
                  rate: ...;
              }>, void, any>;
              step: Command<TypeFromFields<{
                  optionsMask: ...;
                  optionsOverride: ...;
                  stepMode: ...;
                  stepSize: ...;
                  transitionTime: ...;
              }>, void, any>;
              stepWithOnOff: Command<TypeFromFields<{
                  optionsMask: ...;
                  optionsOverride: ...;
                  stepMode: ...;
                  stepSize: ...;
                  transitionTime: ...;
              }>, void, any>;
              stop: Command<TypeFromFields<{
                  optionsMask: ...;
                  optionsOverride: ...;
              }>, void, any>;
              stopWithOnOff: Command<TypeFromFields<{
                  optionsMask: ...;
                  optionsOverride: ...;
              }>, void, any>;
          };
          features: {
              frequency: BitFlag;
              lighting: BitFlag;
              onOff: BitFlag;
          };
          id: Branded<8, "ClusterId">;
          name: "LevelControl";
          revision: 5;
      }>, FlagsT>);
      events: {};
      extensions: undefined;
      features: {
          frequency: BitFlag;
          lighting: BitFlag;
          onOff: BitFlag;
      };
      id: 28;
      name: "PulseWidthModulation";
      revision: 5;
      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: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              currentLevel: Attribute<null | number, any>;
              defaultMoveRate: OptionalWritableAttribute<null | number, any>;
              featureMap: Attribute<TypeFromPartialBitSchema<{
                  frequency: ...;
                  lighting: ...;
                  onOff: ...;
              }>, never>;
              generatedCommandList: Attribute<CommandId[], never>;
              maxFrequency: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              maxLevel: OptionalAttribute<number, any>;
              minFrequency: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              minLevel: OptionalAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              offTransitionTime: OptionalWritableAttribute<null | number, any>;
              onLevel: WritableAttribute<null | number, any>;
              onOffTransitionTime: OptionalWritableAttribute<number, any>;
              onTransitionTime: OptionalWritableAttribute<null | number, any>;
              options: WritableAttribute<TypeFromPartialBitSchema<{
                  coupleColorTempToLevel: ...;
                  executeIfOff: ...;
              }>, any>;
              remainingTime: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              startUpCurrentLevel: WritableAttribute<(...) | (...), any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
          };
          commands: {
              move: Command<TypeFromFields<{
                  moveMode: ...;
                  optionsMask: ...;
                  optionsOverride: ...;
                  rate: ...;
              }>, void, any>;
              moveToClosestFrequency: Command<TypeFromFields<(...)>, void, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              moveToLevel: Command<TypeFromFields<{
                  level: ...;
                  optionsMask: ...;
                  optionsOverride: ...;
                  transitionTime: ...;
              }>, void, any>;
              moveToLevelWithOnOff: Command<TypeFromFields<{
                  level: ...;
                  optionsMask: ...;
                  optionsOverride: ...;
                  transitionTime: ...;
              }>, void, any>;
              moveWithOnOff: Command<TypeFromFields<{
                  moveMode: ...;
                  optionsMask: ...;
                  optionsOverride: ...;
                  rate: ...;
              }>, void, any>;
              step: Command<TypeFromFields<{
                  optionsMask: ...;
                  optionsOverride: ...;
                  stepMode: ...;
                  stepSize: ...;
                  transitionTime: ...;
              }>, void, any>;
              stepWithOnOff: Command<TypeFromFields<{
                  optionsMask: ...;
                  optionsOverride: ...;
                  stepMode: ...;
                  stepSize: ...;
                  transitionTime: ...;
              }>, void, any>;
              stop: Command<TypeFromFields<{
                  optionsMask: ...;
                  optionsOverride: ...;
              }>, void, any>;
              stopWithOnOff: Command<TypeFromFields<{
                  optionsMask: ...;
                  optionsOverride: ...;
              }>, void, any>;
          };
          features: {
              frequency: BitFlag;
              lighting: BitFlag;
              onOff: BitFlag;
          };
          id: Branded<8, "ClusterId">;
          name: "LevelControl";
          revision: 5;
      }>, ValuesT>);
      supportedFeatures: {};
      unknown: false;
      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: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              currentLevel: Attribute<null | number, any>;
              defaultMoveRate: OptionalWritableAttribute<null | number, any>;
              featureMap: Attribute<TypeFromPartialBitSchema<{
                  frequency: ...;
                  lighting: ...;
                  onOff: ...;
              }>, never>;
              generatedCommandList: Attribute<CommandId[], never>;
              maxFrequency: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              maxLevel: OptionalAttribute<number, any>;
              minFrequency: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              minLevel: OptionalAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              offTransitionTime: OptionalWritableAttribute<null | number, any>;
              onLevel: WritableAttribute<null | number, any>;
              onOffTransitionTime: OptionalWritableAttribute<number, any>;
              onTransitionTime: OptionalWritableAttribute<null | number, any>;
              options: WritableAttribute<TypeFromPartialBitSchema<{
                  coupleColorTempToLevel: ...;
                  executeIfOff: ...;
              }>, any>;
              remainingTime: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              startUpCurrentLevel: WritableAttribute<(...) | (...), any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
          };
          commands: {
              move: Command<TypeFromFields<{
                  moveMode: ...;
                  optionsMask: ...;
                  optionsOverride: ...;
                  rate: ...;
              }>, void, any>;
              moveToClosestFrequency: Command<TypeFromFields<(...)>, void, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              moveToLevel: Command<TypeFromFields<{
                  level: ...;
                  optionsMask: ...;
                  optionsOverride: ...;
                  transitionTime: ...;
              }>, void, any>;
              moveToLevelWithOnOff: Command<TypeFromFields<{
                  level: ...;
                  optionsMask: ...;
                  optionsOverride: ...;
                  transitionTime: ...;
              }>, void, any>;
              moveWithOnOff: Command<TypeFromFields<{
                  moveMode: ...;
                  optionsMask: ...;
                  optionsOverride: ...;
                  rate: ...;
              }>, void, any>;
              step: Command<TypeFromFields<{
                  optionsMask: ...;
                  optionsOverride: ...;
                  stepMode: ...;
                  stepSize: ...;
                  transitionTime: ...;
              }>, void, any>;
              stepWithOnOff: Command<TypeFromFields<{
                  optionsMask: ...;
                  optionsOverride: ...;
                  stepMode: ...;
                  stepSize: ...;
                  transitionTime: ...;
              }>, void, any>;
              stop: Command<TypeFromFields<{
                  optionsMask: ...;
                  optionsOverride: ...;
              }>, void, any>;
              stopWithOnOff: Command<TypeFromFields<{
                  optionsMask: ...;
                  optionsOverride: ...;
              }>, void, any>;
          };
          features: {
              frequency: BitFlag;
              lighting: BitFlag;
              onOff: BitFlag;
          };
          id: Branded<8, "ClusterId">;
          name: "LevelControl";
          revision: 5;
      }>, SelectionT>);
  }>>
Parameters
- flags: FlagsT
Returns WithFlags<Of<{
    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: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            currentLevel: Attribute<null | number, any>;
            defaultMoveRate: OptionalWritableAttribute<null | number, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                frequency: ...;
                lighting: ...;
                onOff: ...;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maxFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            maxLevel: OptionalAttribute<number, any>;
            minFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            minLevel: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            offTransitionTime: OptionalWritableAttribute<null | number, any>;
            onLevel: WritableAttribute<null | number, any>;
            onOffTransitionTime: OptionalWritableAttribute<number, any>;
            onTransitionTime: OptionalWritableAttribute<null | number, any>;
            options: WritableAttribute<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: ...;
                executeIfOff: ...;
            }>, any>;
            remainingTime: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            startUpCurrentLevel: WritableAttribute<(...) | (...), any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
        };
        commands: {
            move: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            moveToClosestFrequency: Command<TypeFromFields<(...)>, void, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            moveToLevel: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveToLevelWithOnOff: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveWithOnOff: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            step: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stepWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stop: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
            stopWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
        };
        features: {
            frequency: BitFlag;
            lighting: BitFlag;
            onOff: BitFlag;
        };
        id: Branded<8, "ClusterId">;
        name: "LevelControl";
        revision: 5;
    }>, AlterationsT>);
    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>;
    };
    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: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            currentLevel: Attribute<null | number, any>;
            defaultMoveRate: OptionalWritableAttribute<null | number, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                frequency: ...;
                lighting: ...;
                onOff: ...;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maxFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            maxLevel: OptionalAttribute<number, any>;
            minFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            minLevel: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            offTransitionTime: OptionalWritableAttribute<null | number, any>;
            onLevel: WritableAttribute<null | number, any>;
            onOffTransitionTime: OptionalWritableAttribute<number, any>;
            onTransitionTime: OptionalWritableAttribute<null | number, any>;
            options: WritableAttribute<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: ...;
                executeIfOff: ...;
            }>, any>;
            remainingTime: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            startUpCurrentLevel: WritableAttribute<(...) | (...), any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
        };
        commands: {
            move: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            moveToClosestFrequency: Command<TypeFromFields<(...)>, void, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            moveToLevel: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveToLevelWithOnOff: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveWithOnOff: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            step: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stepWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stop: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
            stopWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
        };
        features: {
            frequency: BitFlag;
            lighting: BitFlag;
            onOff: BitFlag;
        };
        id: Branded<8, "ClusterId">;
        name: "LevelControl";
        revision: 5;
    }>, FlagsT>);
    events: {};
    extensions: undefined;
    features: {
        frequency: BitFlag;
        lighting: BitFlag;
        onOff: BitFlag;
    };
    id: 28;
    name: "PulseWidthModulation";
    revision: 5;
    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: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            currentLevel: Attribute<null | number, any>;
            defaultMoveRate: OptionalWritableAttribute<null | number, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                frequency: ...;
                lighting: ...;
                onOff: ...;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maxFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            maxLevel: OptionalAttribute<number, any>;
            minFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            minLevel: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            offTransitionTime: OptionalWritableAttribute<null | number, any>;
            onLevel: WritableAttribute<null | number, any>;
            onOffTransitionTime: OptionalWritableAttribute<number, any>;
            onTransitionTime: OptionalWritableAttribute<null | number, any>;
            options: WritableAttribute<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: ...;
                executeIfOff: ...;
            }>, any>;
            remainingTime: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            startUpCurrentLevel: WritableAttribute<(...) | (...), any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
        };
        commands: {
            move: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            moveToClosestFrequency: Command<TypeFromFields<(...)>, void, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            moveToLevel: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveToLevelWithOnOff: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveWithOnOff: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            step: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stepWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stop: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
            stopWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
        };
        features: {
            frequency: BitFlag;
            lighting: BitFlag;
            onOff: BitFlag;
        };
        id: Branded<8, "ClusterId">;
        name: "LevelControl";
        revision: 5;
    }>, ValuesT>);
    supportedFeatures: {};
    unknown: false;
    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: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            currentLevel: Attribute<null | number, any>;
            defaultMoveRate: OptionalWritableAttribute<null | number, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                frequency: ...;
                lighting: ...;
                onOff: ...;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maxFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            maxLevel: OptionalAttribute<number, any>;
            minFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            minLevel: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            offTransitionTime: OptionalWritableAttribute<null | number, any>;
            onLevel: WritableAttribute<null | number, any>;
            onOffTransitionTime: OptionalWritableAttribute<number, any>;
            onTransitionTime: OptionalWritableAttribute<null | number, any>;
            options: WritableAttribute<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: ...;
                executeIfOff: ...;
            }>, any>;
            remainingTime: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            startUpCurrentLevel: WritableAttribute<(...) | (...), any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
        };
        commands: {
            move: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            moveToClosestFrequency: Command<TypeFromFields<(...)>, void, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            moveToLevel: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveToLevelWithOnOff: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveWithOnOff: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            step: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stepWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stop: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
            stopWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
        };
        features: {
            frequency: BitFlag;
            lighting: BitFlag;
            onOff: BitFlag;
        };
        id: Branded<8, "ClusterId">;
        name: "LevelControl";
        revision: 5;
    }>, SelectionT>);
}>, FlagsT>
Inherited from Identity.enable
- Defined in packages/types/dist/esm/cluster/mutation/MutableCluster.d.ts:45

set

set<const ValuesT>(values): WithValues<Of<{
    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: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            currentLevel: Attribute<null | number, any>;
            defaultMoveRate: OptionalWritableAttribute<null | number, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                frequency: ...;
                lighting: ...;
                onOff: ...;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maxFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            maxLevel: OptionalAttribute<number, any>;
            minFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            minLevel: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            offTransitionTime: OptionalWritableAttribute<null | number, any>;
            onLevel: WritableAttribute<null | number, any>;
            onOffTransitionTime: OptionalWritableAttribute<number, any>;
            onTransitionTime: OptionalWritableAttribute<null | number, any>;
            options: WritableAttribute<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: ...;
                executeIfOff: ...;
            }>, any>;
            remainingTime: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            startUpCurrentLevel: WritableAttribute<(...) | (...), any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
        };
        commands: {
            move: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            moveToClosestFrequency: Command<TypeFromFields<(...)>, void, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            moveToLevel: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveToLevelWithOnOff: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveWithOnOff: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            step: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stepWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stop: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
            stopWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
        };
        features: {
            frequency: BitFlag;
            lighting: BitFlag;
            onOff: BitFlag;
        };
        id: Branded<8, "ClusterId">;
        name: "LevelControl";
        revision: 5;
    }>, AlterationsT>);
    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>;
    };
    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: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            currentLevel: Attribute<null | number, any>;
            defaultMoveRate: OptionalWritableAttribute<null | number, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                frequency: ...;
                lighting: ...;
                onOff: ...;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maxFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            maxLevel: OptionalAttribute<number, any>;
            minFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            minLevel: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            offTransitionTime: OptionalWritableAttribute<null | number, any>;
            onLevel: WritableAttribute<null | number, any>;
            onOffTransitionTime: OptionalWritableAttribute<number, any>;
            onTransitionTime: OptionalWritableAttribute<null | number, any>;
            options: WritableAttribute<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: ...;
                executeIfOff: ...;
            }>, any>;
            remainingTime: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            startUpCurrentLevel: WritableAttribute<(...) | (...), any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
        };
        commands: {
            move: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            moveToClosestFrequency: Command<TypeFromFields<(...)>, void, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            moveToLevel: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveToLevelWithOnOff: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveWithOnOff: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            step: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stepWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stop: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
            stopWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
        };
        features: {
            frequency: BitFlag;
            lighting: BitFlag;
            onOff: BitFlag;
        };
        id: Branded<8, "ClusterId">;
        name: "LevelControl";
        revision: 5;
    }>, FlagsT>);
    events: {};
    extensions: undefined;
    features: {
        frequency: BitFlag;
        lighting: BitFlag;
        onOff: BitFlag;
    };
    id: 28;
    name: "PulseWidthModulation";
    revision: 5;
    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: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            currentLevel: Attribute<null | number, any>;
            defaultMoveRate: OptionalWritableAttribute<null | number, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                frequency: ...;
                lighting: ...;
                onOff: ...;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maxFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            maxLevel: OptionalAttribute<number, any>;
            minFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            minLevel: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            offTransitionTime: OptionalWritableAttribute<null | number, any>;
            onLevel: WritableAttribute<null | number, any>;
            onOffTransitionTime: OptionalWritableAttribute<number, any>;
            onTransitionTime: OptionalWritableAttribute<null | number, any>;
            options: WritableAttribute<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: ...;
                executeIfOff: ...;
            }>, any>;
            remainingTime: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            startUpCurrentLevel: WritableAttribute<(...) | (...), any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
        };
        commands: {
            move: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            moveToClosestFrequency: Command<TypeFromFields<(...)>, void, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            moveToLevel: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveToLevelWithOnOff: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveWithOnOff: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            step: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stepWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stop: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
            stopWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
        };
        features: {
            frequency: BitFlag;
            lighting: BitFlag;
            onOff: BitFlag;
        };
        id: Branded<8, "ClusterId">;
        name: "LevelControl";
        revision: 5;
    }>, ValuesT>);
    supportedFeatures: {};
    unknown: false;
    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: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            currentLevel: Attribute<null | number, any>;
            defaultMoveRate: OptionalWritableAttribute<null | number, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                frequency: ...;
                lighting: ...;
                onOff: ...;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maxFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            maxLevel: OptionalAttribute<number, any>;
            minFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            minLevel: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            offTransitionTime: OptionalWritableAttribute<null | number, any>;
            onLevel: WritableAttribute<null | number, any>;
            onOffTransitionTime: OptionalWritableAttribute<number, any>;
            onTransitionTime: OptionalWritableAttribute<null | number, any>;
            options: WritableAttribute<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: ...;
                executeIfOff: ...;
            }>, any>;
            remainingTime: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            startUpCurrentLevel: WritableAttribute<(...) | (...), any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
        };
        commands: {
            move: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            moveToClosestFrequency: Command<TypeFromFields<(...)>, void, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            moveToLevel: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveToLevelWithOnOff: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveWithOnOff: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            step: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stepWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stop: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
            stopWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
        };
        features: {
            frequency: BitFlag;
            lighting: BitFlag;
            onOff: BitFlag;
        };
        id: Branded<8, "ClusterId">;
        name: "LevelControl";
        revision: 5;
    }>, SelectionT>);
}>, 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
- values: ValuesT
Returns WithValues<Of<{
    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: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            currentLevel: Attribute<null | number, any>;
            defaultMoveRate: OptionalWritableAttribute<null | number, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                frequency: ...;
                lighting: ...;
                onOff: ...;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maxFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            maxLevel: OptionalAttribute<number, any>;
            minFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            minLevel: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            offTransitionTime: OptionalWritableAttribute<null | number, any>;
            onLevel: WritableAttribute<null | number, any>;
            onOffTransitionTime: OptionalWritableAttribute<number, any>;
            onTransitionTime: OptionalWritableAttribute<null | number, any>;
            options: WritableAttribute<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: ...;
                executeIfOff: ...;
            }>, any>;
            remainingTime: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            startUpCurrentLevel: WritableAttribute<(...) | (...), any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
        };
        commands: {
            move: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            moveToClosestFrequency: Command<TypeFromFields<(...)>, void, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            moveToLevel: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveToLevelWithOnOff: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveWithOnOff: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            step: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stepWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stop: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
            stopWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
        };
        features: {
            frequency: BitFlag;
            lighting: BitFlag;
            onOff: BitFlag;
        };
        id: Branded<8, "ClusterId">;
        name: "LevelControl";
        revision: 5;
    }>, AlterationsT>);
    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>;
    };
    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: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            currentLevel: Attribute<null | number, any>;
            defaultMoveRate: OptionalWritableAttribute<null | number, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                frequency: ...;
                lighting: ...;
                onOff: ...;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maxFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            maxLevel: OptionalAttribute<number, any>;
            minFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            minLevel: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            offTransitionTime: OptionalWritableAttribute<null | number, any>;
            onLevel: WritableAttribute<null | number, any>;
            onOffTransitionTime: OptionalWritableAttribute<number, any>;
            onTransitionTime: OptionalWritableAttribute<null | number, any>;
            options: WritableAttribute<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: ...;
                executeIfOff: ...;
            }>, any>;
            remainingTime: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            startUpCurrentLevel: WritableAttribute<(...) | (...), any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
        };
        commands: {
            move: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            moveToClosestFrequency: Command<TypeFromFields<(...)>, void, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            moveToLevel: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveToLevelWithOnOff: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveWithOnOff: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            step: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stepWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stop: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
            stopWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
        };
        features: {
            frequency: BitFlag;
            lighting: BitFlag;
            onOff: BitFlag;
        };
        id: Branded<8, "ClusterId">;
        name: "LevelControl";
        revision: 5;
    }>, FlagsT>);
    events: {};
    extensions: undefined;
    features: {
        frequency: BitFlag;
        lighting: BitFlag;
        onOff: BitFlag;
    };
    id: 28;
    name: "PulseWidthModulation";
    revision: 5;
    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: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            currentLevel: Attribute<null | number, any>;
            defaultMoveRate: OptionalWritableAttribute<null | number, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                frequency: ...;
                lighting: ...;
                onOff: ...;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maxFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            maxLevel: OptionalAttribute<number, any>;
            minFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            minLevel: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            offTransitionTime: OptionalWritableAttribute<null | number, any>;
            onLevel: WritableAttribute<null | number, any>;
            onOffTransitionTime: OptionalWritableAttribute<number, any>;
            onTransitionTime: OptionalWritableAttribute<null | number, any>;
            options: WritableAttribute<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: ...;
                executeIfOff: ...;
            }>, any>;
            remainingTime: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            startUpCurrentLevel: WritableAttribute<(...) | (...), any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
        };
        commands: {
            move: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            moveToClosestFrequency: Command<TypeFromFields<(...)>, void, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            moveToLevel: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveToLevelWithOnOff: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveWithOnOff: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            step: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stepWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stop: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
            stopWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
        };
        features: {
            frequency: BitFlag;
            lighting: BitFlag;
            onOff: BitFlag;
        };
        id: Branded<8, "ClusterId">;
        name: "LevelControl";
        revision: 5;
    }>, ValuesT>);
    supportedFeatures: {};
    unknown: false;
    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: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            currentLevel: Attribute<null | number, any>;
            defaultMoveRate: OptionalWritableAttribute<null | number, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                frequency: ...;
                lighting: ...;
                onOff: ...;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maxFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            maxLevel: OptionalAttribute<number, any>;
            minFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            minLevel: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            offTransitionTime: OptionalWritableAttribute<null | number, any>;
            onLevel: WritableAttribute<null | number, any>;
            onOffTransitionTime: OptionalWritableAttribute<number, any>;
            onTransitionTime: OptionalWritableAttribute<null | number, any>;
            options: WritableAttribute<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: ...;
                executeIfOff: ...;
            }>, any>;
            remainingTime: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            startUpCurrentLevel: WritableAttribute<(...) | (...), any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
        };
        commands: {
            move: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            moveToClosestFrequency: Command<TypeFromFields<(...)>, void, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            moveToLevel: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveToLevelWithOnOff: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveWithOnOff: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            step: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stepWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stop: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
            stopWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
        };
        features: {
            frequency: BitFlag;
            lighting: BitFlag;
            onOff: BitFlag;
        };
        id: Branded<8, "ClusterId">;
        name: "LevelControl";
        revision: 5;
    }>, SelectionT>);
}>, ValuesT>
Inherited from Identity.set
- Defined in packages/types/dist/esm/cluster/mutation/MutableCluster.d.ts:41

with

with<const SelectionT>(...selection): Of<Of<{
    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: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            currentLevel: Attribute<null | number, any>;
            defaultMoveRate: OptionalWritableAttribute<null | number, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                frequency: ...;
                lighting: ...;
                onOff: ...;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maxFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            maxLevel: OptionalAttribute<number, any>;
            minFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            minLevel: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            offTransitionTime: OptionalWritableAttribute<null | number, any>;
            onLevel: WritableAttribute<null | number, any>;
            onOffTransitionTime: OptionalWritableAttribute<number, any>;
            onTransitionTime: OptionalWritableAttribute<null | number, any>;
            options: WritableAttribute<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: ...;
                executeIfOff: ...;
            }>, any>;
            remainingTime: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            startUpCurrentLevel: WritableAttribute<(...) | (...), any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
        };
        commands: {
            move: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            moveToClosestFrequency: Command<TypeFromFields<(...)>, void, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            moveToLevel: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveToLevelWithOnOff: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveWithOnOff: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            step: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stepWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stop: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
            stopWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
        };
        features: {
            frequency: BitFlag;
            lighting: BitFlag;
            onOff: BitFlag;
        };
        id: Branded<8, "ClusterId">;
        name: "LevelControl";
        revision: 5;
    }>, AlterationsT>);
    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>;
    };
    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: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            currentLevel: Attribute<null | number, any>;
            defaultMoveRate: OptionalWritableAttribute<null | number, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                frequency: ...;
                lighting: ...;
                onOff: ...;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maxFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            maxLevel: OptionalAttribute<number, any>;
            minFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            minLevel: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            offTransitionTime: OptionalWritableAttribute<null | number, any>;
            onLevel: WritableAttribute<null | number, any>;
            onOffTransitionTime: OptionalWritableAttribute<number, any>;
            onTransitionTime: OptionalWritableAttribute<null | number, any>;
            options: WritableAttribute<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: ...;
                executeIfOff: ...;
            }>, any>;
            remainingTime: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            startUpCurrentLevel: WritableAttribute<(...) | (...), any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
        };
        commands: {
            move: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            moveToClosestFrequency: Command<TypeFromFields<(...)>, void, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            moveToLevel: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveToLevelWithOnOff: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveWithOnOff: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            step: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stepWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stop: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
            stopWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
        };
        features: {
            frequency: BitFlag;
            lighting: BitFlag;
            onOff: BitFlag;
        };
        id: Branded<8, "ClusterId">;
        name: "LevelControl";
        revision: 5;
    }>, FlagsT>);
    events: {};
    extensions: undefined;
    features: {
        frequency: BitFlag;
        lighting: BitFlag;
        onOff: BitFlag;
    };
    id: 28;
    name: "PulseWidthModulation";
    revision: 5;
    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: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            currentLevel: Attribute<null | number, any>;
            defaultMoveRate: OptionalWritableAttribute<null | number, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                frequency: ...;
                lighting: ...;
                onOff: ...;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maxFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            maxLevel: OptionalAttribute<number, any>;
            minFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            minLevel: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            offTransitionTime: OptionalWritableAttribute<null | number, any>;
            onLevel: WritableAttribute<null | number, any>;
            onOffTransitionTime: OptionalWritableAttribute<number, any>;
            onTransitionTime: OptionalWritableAttribute<null | number, any>;
            options: WritableAttribute<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: ...;
                executeIfOff: ...;
            }>, any>;
            remainingTime: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            startUpCurrentLevel: WritableAttribute<(...) | (...), any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
        };
        commands: {
            move: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            moveToClosestFrequency: Command<TypeFromFields<(...)>, void, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            moveToLevel: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveToLevelWithOnOff: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveWithOnOff: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            step: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stepWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stop: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
            stopWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
        };
        features: {
            frequency: BitFlag;
            lighting: BitFlag;
            onOff: BitFlag;
        };
        id: Branded<8, "ClusterId">;
        name: "LevelControl";
        revision: 5;
    }>, ValuesT>);
    supportedFeatures: {};
    unknown: false;
    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: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            currentLevel: Attribute<null | number, any>;
            defaultMoveRate: OptionalWritableAttribute<null | number, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                frequency: ...;
                lighting: ...;
                onOff: ...;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maxFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            maxLevel: OptionalAttribute<number, any>;
            minFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            minLevel: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            offTransitionTime: OptionalWritableAttribute<null | number, any>;
            onLevel: WritableAttribute<null | number, any>;
            onOffTransitionTime: OptionalWritableAttribute<number, any>;
            onTransitionTime: OptionalWritableAttribute<null | number, any>;
            options: WritableAttribute<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: ...;
                executeIfOff: ...;
            }>, any>;
            remainingTime: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            startUpCurrentLevel: WritableAttribute<(...) | (...), any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
        };
        commands: {
            move: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            moveToClosestFrequency: Command<TypeFromFields<(...)>, void, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            moveToLevel: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveToLevelWithOnOff: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveWithOnOff: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            step: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stepWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stop: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
            stopWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
        };
        features: {
            frequency: BitFlag;
            lighting: BitFlag;
            onOff: BitFlag;
        };
        id: Branded<8, "ClusterId">;
        name: "LevelControl";
        revision: 5;
    }>, SelectionT>);
}>, SelectionT>
Select features using ClusterComposer.compose.
Type Parameters
- const SelectionT extends FeatureSelection<Of<{
      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: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              currentLevel: Attribute<null | number, any>;
              defaultMoveRate: OptionalWritableAttribute<null | number, any>;
              featureMap: Attribute<TypeFromPartialBitSchema<{
                  frequency: ...;
                  lighting: ...;
                  onOff: ...;
              }>, never>;
              generatedCommandList: Attribute<CommandId[], never>;
              maxFrequency: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              maxLevel: OptionalAttribute<number, any>;
              minFrequency: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              minLevel: OptionalAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              offTransitionTime: OptionalWritableAttribute<null | number, any>;
              onLevel: WritableAttribute<null | number, any>;
              onOffTransitionTime: OptionalWritableAttribute<number, any>;
              onTransitionTime: OptionalWritableAttribute<null | number, any>;
              options: WritableAttribute<TypeFromPartialBitSchema<{
                  coupleColorTempToLevel: ...;
                  executeIfOff: ...;
              }>, any>;
              remainingTime: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              startUpCurrentLevel: WritableAttribute<(...) | (...), any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
          };
          commands: {
              move: Command<TypeFromFields<{
                  moveMode: ...;
                  optionsMask: ...;
                  optionsOverride: ...;
                  rate: ...;
              }>, void, any>;
              moveToClosestFrequency: Command<TypeFromFields<(...)>, void, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              moveToLevel: Command<TypeFromFields<{
                  level: ...;
                  optionsMask: ...;
                  optionsOverride: ...;
                  transitionTime: ...;
              }>, void, any>;
              moveToLevelWithOnOff: Command<TypeFromFields<{
                  level: ...;
                  optionsMask: ...;
                  optionsOverride: ...;
                  transitionTime: ...;
              }>, void, any>;
              moveWithOnOff: Command<TypeFromFields<{
                  moveMode: ...;
                  optionsMask: ...;
                  optionsOverride: ...;
                  rate: ...;
              }>, void, any>;
              step: Command<TypeFromFields<{
                  optionsMask: ...;
                  optionsOverride: ...;
                  stepMode: ...;
                  stepSize: ...;
                  transitionTime: ...;
              }>, void, any>;
              stepWithOnOff: Command<TypeFromFields<{
                  optionsMask: ...;
                  optionsOverride: ...;
                  stepMode: ...;
                  stepSize: ...;
                  transitionTime: ...;
              }>, void, any>;
              stop: Command<TypeFromFields<{
                  optionsMask: ...;
                  optionsOverride: ...;
              }>, void, any>;
              stopWithOnOff: Command<TypeFromFields<{
                  optionsMask: ...;
                  optionsOverride: ...;
              }>, void, any>;
          };
          features: {
              frequency: BitFlag;
              lighting: BitFlag;
              onOff: BitFlag;
          };
          id: Branded<8, "ClusterId">;
          name: "LevelControl";
          revision: 5;
      }>, AlterationsT>);
      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>;
      };
      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: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              currentLevel: Attribute<null | number, any>;
              defaultMoveRate: OptionalWritableAttribute<null | number, any>;
              featureMap: Attribute<TypeFromPartialBitSchema<{
                  frequency: ...;
                  lighting: ...;
                  onOff: ...;
              }>, never>;
              generatedCommandList: Attribute<CommandId[], never>;
              maxFrequency: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              maxLevel: OptionalAttribute<number, any>;
              minFrequency: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              minLevel: OptionalAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              offTransitionTime: OptionalWritableAttribute<null | number, any>;
              onLevel: WritableAttribute<null | number, any>;
              onOffTransitionTime: OptionalWritableAttribute<number, any>;
              onTransitionTime: OptionalWritableAttribute<null | number, any>;
              options: WritableAttribute<TypeFromPartialBitSchema<{
                  coupleColorTempToLevel: ...;
                  executeIfOff: ...;
              }>, any>;
              remainingTime: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              startUpCurrentLevel: WritableAttribute<(...) | (...), any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
          };
          commands: {
              move: Command<TypeFromFields<{
                  moveMode: ...;
                  optionsMask: ...;
                  optionsOverride: ...;
                  rate: ...;
              }>, void, any>;
              moveToClosestFrequency: Command<TypeFromFields<(...)>, void, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              moveToLevel: Command<TypeFromFields<{
                  level: ...;
                  optionsMask: ...;
                  optionsOverride: ...;
                  transitionTime: ...;
              }>, void, any>;
              moveToLevelWithOnOff: Command<TypeFromFields<{
                  level: ...;
                  optionsMask: ...;
                  optionsOverride: ...;
                  transitionTime: ...;
              }>, void, any>;
              moveWithOnOff: Command<TypeFromFields<{
                  moveMode: ...;
                  optionsMask: ...;
                  optionsOverride: ...;
                  rate: ...;
              }>, void, any>;
              step: Command<TypeFromFields<{
                  optionsMask: ...;
                  optionsOverride: ...;
                  stepMode: ...;
                  stepSize: ...;
                  transitionTime: ...;
              }>, void, any>;
              stepWithOnOff: Command<TypeFromFields<{
                  optionsMask: ...;
                  optionsOverride: ...;
                  stepMode: ...;
                  stepSize: ...;
                  transitionTime: ...;
              }>, void, any>;
              stop: Command<TypeFromFields<{
                  optionsMask: ...;
                  optionsOverride: ...;
              }>, void, any>;
              stopWithOnOff: Command<TypeFromFields<{
                  optionsMask: ...;
                  optionsOverride: ...;
              }>, void, any>;
          };
          features: {
              frequency: BitFlag;
              lighting: BitFlag;
              onOff: BitFlag;
          };
          id: Branded<8, "ClusterId">;
          name: "LevelControl";
          revision: 5;
      }>, FlagsT>);
      events: {};
      extensions: undefined;
      features: {
          frequency: BitFlag;
          lighting: BitFlag;
          onOff: BitFlag;
      };
      id: 28;
      name: "PulseWidthModulation";
      revision: 5;
      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: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              currentLevel: Attribute<null | number, any>;
              defaultMoveRate: OptionalWritableAttribute<null | number, any>;
              featureMap: Attribute<TypeFromPartialBitSchema<{
                  frequency: ...;
                  lighting: ...;
                  onOff: ...;
              }>, never>;
              generatedCommandList: Attribute<CommandId[], never>;
              maxFrequency: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              maxLevel: OptionalAttribute<number, any>;
              minFrequency: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              minLevel: OptionalAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              offTransitionTime: OptionalWritableAttribute<null | number, any>;
              onLevel: WritableAttribute<null | number, any>;
              onOffTransitionTime: OptionalWritableAttribute<number, any>;
              onTransitionTime: OptionalWritableAttribute<null | number, any>;
              options: WritableAttribute<TypeFromPartialBitSchema<{
                  coupleColorTempToLevel: ...;
                  executeIfOff: ...;
              }>, any>;
              remainingTime: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              startUpCurrentLevel: WritableAttribute<(...) | (...), any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
          };
          commands: {
              move: Command<TypeFromFields<{
                  moveMode: ...;
                  optionsMask: ...;
                  optionsOverride: ...;
                  rate: ...;
              }>, void, any>;
              moveToClosestFrequency: Command<TypeFromFields<(...)>, void, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              moveToLevel: Command<TypeFromFields<{
                  level: ...;
                  optionsMask: ...;
                  optionsOverride: ...;
                  transitionTime: ...;
              }>, void, any>;
              moveToLevelWithOnOff: Command<TypeFromFields<{
                  level: ...;
                  optionsMask: ...;
                  optionsOverride: ...;
                  transitionTime: ...;
              }>, void, any>;
              moveWithOnOff: Command<TypeFromFields<{
                  moveMode: ...;
                  optionsMask: ...;
                  optionsOverride: ...;
                  rate: ...;
              }>, void, any>;
              step: Command<TypeFromFields<{
                  optionsMask: ...;
                  optionsOverride: ...;
                  stepMode: ...;
                  stepSize: ...;
                  transitionTime: ...;
              }>, void, any>;
              stepWithOnOff: Command<TypeFromFields<{
                  optionsMask: ...;
                  optionsOverride: ...;
                  stepMode: ...;
                  stepSize: ...;
                  transitionTime: ...;
              }>, void, any>;
              stop: Command<TypeFromFields<{
                  optionsMask: ...;
                  optionsOverride: ...;
              }>, void, any>;
              stopWithOnOff: Command<TypeFromFields<{
                  optionsMask: ...;
                  optionsOverride: ...;
              }>, void, any>;
          };
          features: {
              frequency: BitFlag;
              lighting: BitFlag;
              onOff: BitFlag;
          };
          id: Branded<8, "ClusterId">;
          name: "LevelControl";
          revision: 5;
      }>, ValuesT>);
      supportedFeatures: {};
      unknown: false;
      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: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              currentLevel: Attribute<null | number, any>;
              defaultMoveRate: OptionalWritableAttribute<null | number, any>;
              featureMap: Attribute<TypeFromPartialBitSchema<{
                  frequency: ...;
                  lighting: ...;
                  onOff: ...;
              }>, never>;
              generatedCommandList: Attribute<CommandId[], never>;
              maxFrequency: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              maxLevel: OptionalAttribute<number, any>;
              minFrequency: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              minLevel: OptionalAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              offTransitionTime: OptionalWritableAttribute<null | number, any>;
              onLevel: WritableAttribute<null | number, any>;
              onOffTransitionTime: OptionalWritableAttribute<number, any>;
              onTransitionTime: OptionalWritableAttribute<null | number, any>;
              options: WritableAttribute<TypeFromPartialBitSchema<{
                  coupleColorTempToLevel: ...;
                  executeIfOff: ...;
              }>, any>;
              remainingTime: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              startUpCurrentLevel: WritableAttribute<(...) | (...), any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
          };
          commands: {
              move: Command<TypeFromFields<{
                  moveMode: ...;
                  optionsMask: ...;
                  optionsOverride: ...;
                  rate: ...;
              }>, void, any>;
              moveToClosestFrequency: Command<TypeFromFields<(...)>, void, any> & {
                  isConditional: true;
                  mandatoryIf: (...) | (...);
                  optional: true;
                  optionalIf: (...) | (...);
              };
              moveToLevel: Command<TypeFromFields<{
                  level: ...;
                  optionsMask: ...;
                  optionsOverride: ...;
                  transitionTime: ...;
              }>, void, any>;
              moveToLevelWithOnOff: Command<TypeFromFields<{
                  level: ...;
                  optionsMask: ...;
                  optionsOverride: ...;
                  transitionTime: ...;
              }>, void, any>;
              moveWithOnOff: Command<TypeFromFields<{
                  moveMode: ...;
                  optionsMask: ...;
                  optionsOverride: ...;
                  rate: ...;
              }>, void, any>;
              step: Command<TypeFromFields<{
                  optionsMask: ...;
                  optionsOverride: ...;
                  stepMode: ...;
                  stepSize: ...;
                  transitionTime: ...;
              }>, void, any>;
              stepWithOnOff: Command<TypeFromFields<{
                  optionsMask: ...;
                  optionsOverride: ...;
                  stepMode: ...;
                  stepSize: ...;
                  transitionTime: ...;
              }>, void, any>;
              stop: Command<TypeFromFields<{
                  optionsMask: ...;
                  optionsOverride: ...;
              }>, void, any>;
              stopWithOnOff: Command<TypeFromFields<{
                  optionsMask: ...;
                  optionsOverride: ...;
              }>, void, any>;
          };
          features: {
              frequency: BitFlag;
              lighting: BitFlag;
              onOff: BitFlag;
          };
          id: Branded<8, "ClusterId">;
          name: "LevelControl";
          revision: 5;
      }>, SelectionT>);
  }>>
Parameters
- Rest...selection: SelectionT
Returns Of<Of<{
    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: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            currentLevel: Attribute<null | number, any>;
            defaultMoveRate: OptionalWritableAttribute<null | number, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                frequency: ...;
                lighting: ...;
                onOff: ...;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maxFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            maxLevel: OptionalAttribute<number, any>;
            minFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            minLevel: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            offTransitionTime: OptionalWritableAttribute<null | number, any>;
            onLevel: WritableAttribute<null | number, any>;
            onOffTransitionTime: OptionalWritableAttribute<number, any>;
            onTransitionTime: OptionalWritableAttribute<null | number, any>;
            options: WritableAttribute<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: ...;
                executeIfOff: ...;
            }>, any>;
            remainingTime: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            startUpCurrentLevel: WritableAttribute<(...) | (...), any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
        };
        commands: {
            move: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            moveToClosestFrequency: Command<TypeFromFields<(...)>, void, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            moveToLevel: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveToLevelWithOnOff: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveWithOnOff: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            step: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stepWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stop: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
            stopWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
        };
        features: {
            frequency: BitFlag;
            lighting: BitFlag;
            onOff: BitFlag;
        };
        id: Branded<8, "ClusterId">;
        name: "LevelControl";
        revision: 5;
    }>, AlterationsT>);
    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>;
    };
    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: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            currentLevel: Attribute<null | number, any>;
            defaultMoveRate: OptionalWritableAttribute<null | number, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                frequency: ...;
                lighting: ...;
                onOff: ...;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maxFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            maxLevel: OptionalAttribute<number, any>;
            minFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            minLevel: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            offTransitionTime: OptionalWritableAttribute<null | number, any>;
            onLevel: WritableAttribute<null | number, any>;
            onOffTransitionTime: OptionalWritableAttribute<number, any>;
            onTransitionTime: OptionalWritableAttribute<null | number, any>;
            options: WritableAttribute<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: ...;
                executeIfOff: ...;
            }>, any>;
            remainingTime: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            startUpCurrentLevel: WritableAttribute<(...) | (...), any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
        };
        commands: {
            move: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            moveToClosestFrequency: Command<TypeFromFields<(...)>, void, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            moveToLevel: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveToLevelWithOnOff: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveWithOnOff: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            step: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stepWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stop: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
            stopWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
        };
        features: {
            frequency: BitFlag;
            lighting: BitFlag;
            onOff: BitFlag;
        };
        id: Branded<8, "ClusterId">;
        name: "LevelControl";
        revision: 5;
    }>, FlagsT>);
    events: {};
    extensions: undefined;
    features: {
        frequency: BitFlag;
        lighting: BitFlag;
        onOff: BitFlag;
    };
    id: 28;
    name: "PulseWidthModulation";
    revision: 5;
    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: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            currentLevel: Attribute<null | number, any>;
            defaultMoveRate: OptionalWritableAttribute<null | number, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                frequency: ...;
                lighting: ...;
                onOff: ...;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maxFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            maxLevel: OptionalAttribute<number, any>;
            minFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            minLevel: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            offTransitionTime: OptionalWritableAttribute<null | number, any>;
            onLevel: WritableAttribute<null | number, any>;
            onOffTransitionTime: OptionalWritableAttribute<number, any>;
            onTransitionTime: OptionalWritableAttribute<null | number, any>;
            options: WritableAttribute<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: ...;
                executeIfOff: ...;
            }>, any>;
            remainingTime: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            startUpCurrentLevel: WritableAttribute<(...) | (...), any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
        };
        commands: {
            move: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            moveToClosestFrequency: Command<TypeFromFields<(...)>, void, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            moveToLevel: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveToLevelWithOnOff: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveWithOnOff: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            step: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stepWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stop: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
            stopWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
        };
        features: {
            frequency: BitFlag;
            lighting: BitFlag;
            onOff: BitFlag;
        };
        id: Branded<8, "ClusterId">;
        name: "LevelControl";
        revision: 5;
    }>, ValuesT>);
    supportedFeatures: {};
    unknown: false;
    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: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            currentLevel: Attribute<null | number, any>;
            defaultMoveRate: OptionalWritableAttribute<null | number, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                frequency: ...;
                lighting: ...;
                onOff: ...;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maxFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            maxLevel: OptionalAttribute<number, any>;
            minFrequency: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            minLevel: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            offTransitionTime: OptionalWritableAttribute<null | number, any>;
            onLevel: WritableAttribute<null | number, any>;
            onOffTransitionTime: OptionalWritableAttribute<number, any>;
            onTransitionTime: OptionalWritableAttribute<null | number, any>;
            options: WritableAttribute<TypeFromPartialBitSchema<{
                coupleColorTempToLevel: ...;
                executeIfOff: ...;
            }>, any>;
            remainingTime: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            startUpCurrentLevel: WritableAttribute<(...) | (...), any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
        };
        commands: {
            move: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            moveToClosestFrequency: Command<TypeFromFields<(...)>, void, any> & {
                isConditional: true;
                mandatoryIf: (...) | (...);
                optional: true;
                optionalIf: (...) | (...);
            };
            moveToLevel: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveToLevelWithOnOff: Command<TypeFromFields<{
                level: ...;
                optionsMask: ...;
                optionsOverride: ...;
                transitionTime: ...;
            }>, void, any>;
            moveWithOnOff: Command<TypeFromFields<{
                moveMode: ...;
                optionsMask: ...;
                optionsOverride: ...;
                rate: ...;
            }>, void, any>;
            step: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stepWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
                stepMode: ...;
                stepSize: ...;
                transitionTime: ...;
            }>, void, any>;
            stop: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
            stopWithOnOff: Command<TypeFromFields<{
                optionsMask: ...;
                optionsOverride: ...;
            }>, void, any>;
        };
        features: {
            frequency: BitFlag;
            lighting: BitFlag;
            onOff: BitFlag;
        };
        id: Branded<8, "ClusterId">;
        name: "LevelControl";
        revision: 5;
    }>, SelectionT>);
}>, SelectionT>
Inherited from Identity.with
- Defined in packages/types/dist/esm/cluster/mutation/MutableCluster.d.ts:33

Interface Complete

Hierarchy (view full)

Index

Properties

Methods

Properties

attributes

base

commands

events

extensions

features

id

name

revision

supportedFeatures

unknown

Methods

alter

Type Parameters

Parameters

enable

Type Parameters

Parameters

set

Type Parameters

Parameters

with

Type Parameters

Parameters

Settings

On This Page