Interface Complete

interface Foo extends typeof Bar {}

interface Foo extends Identity<typeof Bar> {}

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

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