Interface Complete

interface Complete {
    attributes: Merge<{
        acceptedCommandList: Attribute<CommandId[], never>;
        attributeList: Attribute<AttributeId[], never>;
        clusterRevision: Attribute<number, never>;
        colorCapabilities: Attribute<TypeFromPartialBitSchema<{
            colorLoop: BitFlag;
            colorTemperature: BitFlag;
            enhancedHue: BitFlag;
            hueSaturation: BitFlag;
            xy: BitFlag;
        }>, any>;
        colorLoopActive: Attribute<ColorControl.ColorLoopActive, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                colorLoop: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        colorLoopDirection: Attribute<ColorControl.ColorLoopDirection, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                colorLoop: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        colorLoopStartEnhancedHue: Attribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                colorLoop: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        colorLoopStoredEnhancedHue: Attribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                colorLoop: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        colorLoopTime: Attribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                colorLoop: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        colorMode: Attribute<ColorControl.ColorMode, any>;
        colorPointBIntensity: OptionalWritableAttribute<null | number, any>;
        colorPointBx: OptionalWritableAttribute<number, any>;
        colorPointBy: OptionalWritableAttribute<number, any>;
        colorPointGIntensity: OptionalWritableAttribute<null | number, any>;
        colorPointGx: OptionalWritableAttribute<number, any>;
        colorPointGy: OptionalWritableAttribute<number, any>;
        colorPointRIntensity: OptionalWritableAttribute<null | number, any>;
        colorPointRx: OptionalWritableAttribute<number, any>;
        colorPointRy: OptionalWritableAttribute<number, any>;
        colorTemperatureMireds: Attribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                colorTemperature: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        colorTempPhysicalMaxMireds: Attribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                colorTemperature: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        colorTempPhysicalMinMireds: Attribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                colorTemperature: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        compensationText: OptionalAttribute<string, any>;
        coupleColorTempToLevelMinMireds: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                colorTemperature: boolean;
            }];
        };
        currentHue: Attribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                hueSaturation: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        currentSaturation: Attribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                hueSaturation: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        currentX: Attribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                xy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        currentY: Attribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                xy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        driftCompensation: OptionalAttribute<ColorControl.DriftCompensation, any>;
        enhancedColorMode: Attribute<ColorControl.EnhancedColorMode, any>;
        enhancedCurrentHue: Attribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                enhancedHue: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        featureMap: Attribute<TypeFromPartialBitSchema<{
            colorLoop: BitFlag;
            colorTemperature: BitFlag;
            enhancedHue: BitFlag;
            hueSaturation: BitFlag;
            xy: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        numberOfPrimaries: FixedAttribute<null | number, any>;
        options: WritableAttribute<TypeFromPartialBitSchema<{
            executeIfOff: BitFlag;
        }>, any>;
        primary1Intensity: OptionalFixedAttribute<null | number, any>;
        primary1X: OptionalFixedAttribute<number, any>;
        primary1Y: OptionalFixedAttribute<number, any>;
        primary2Intensity: OptionalFixedAttribute<null | number, any>;
        primary2X: OptionalFixedAttribute<number, any>;
        primary2Y: OptionalFixedAttribute<number, any>;
        primary3Intensity: OptionalFixedAttribute<null | number, any>;
        primary3X: OptionalFixedAttribute<number, any>;
        primary3Y: OptionalFixedAttribute<number, any>;
        primary4Intensity: OptionalFixedAttribute<null | number, any>;
        primary4X: OptionalFixedAttribute<number, any>;
        primary4Y: OptionalFixedAttribute<number, any>;
        primary5Intensity: OptionalFixedAttribute<null | number, any>;
        primary5X: OptionalFixedAttribute<number, any>;
        primary5Y: OptionalFixedAttribute<number, any>;
        primary6Intensity: OptionalFixedAttribute<null | number, any>;
        primary6X: OptionalFixedAttribute<number, any>;
        primary6Y: OptionalFixedAttribute<number, any>;
        remainingTime: OptionalAttribute<number, any>;
        startUpColorTemperatureMireds: OptionalWritableAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                colorTemperature: boolean;
            }];
        };
        whitePointX: OptionalWritableAttribute<number, any>;
        whitePointY: OptionalWritableAttribute<number, any>;
    }, GlobalAttributes<{
        colorLoop: BitFlag;
        colorTemperature: BitFlag;
        enhancedHue: BitFlag;
        hueSaturation: BitFlag;
        xy: BitFlag;
    }>>;
    base: undefined;
    commands: {
        colorLoopSet: Command<TypeFromFields<{
            action: FieldType<ColorControl.Action>;
            direction: FieldType<ColorControl.ColorLoopSetDirection>;
            optionsMask: FieldType<TypeFromPartialBitSchema<{
                executeIfOff: BitFlag;
            }>>;
            optionsOverride: FieldType<TypeFromPartialBitSchema<{
                executeIfOff: BitFlag;
            }>>;
            startHue: FieldType<number>;
            time: FieldType<number>;
            updateFlags: FieldType<TypeFromPartialBitSchema<{
                reserved: BitField;
                updateAction: BitFlag;
                updateDirection: BitFlag;
                updateStartHue: BitFlag;
                updateTime: BitFlag;
            }>>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                colorLoop: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        enhancedMoveHue: Command<TypeFromFields<{
            moveMode: FieldType<ColorControl.MoveMode>;
            optionsMask: FieldType<TypeFromPartialBitSchema<{
                executeIfOff: BitFlag;
            }>>;
            optionsOverride: FieldType<TypeFromPartialBitSchema<{
                executeIfOff: BitFlag;
            }>>;
            rate: FieldType<number>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                enhancedHue: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        enhancedMoveToHue: Command<TypeFromFields<{
            direction: FieldType<ColorControl.Direction>;
            enhancedHue: FieldType<number>;
            optionsMask: FieldType<TypeFromPartialBitSchema<{
                executeIfOff: BitFlag;
            }>>;
            optionsOverride: FieldType<TypeFromPartialBitSchema<{
                executeIfOff: BitFlag;
            }>>;
            transitionTime: FieldType<number>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                enhancedHue: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        enhancedMoveToHueAndSaturation: Command<TypeFromFields<{
            enhancedHue: FieldType<number>;
            optionsMask: FieldType<TypeFromPartialBitSchema<{
                executeIfOff: BitFlag;
            }>>;
            optionsOverride: FieldType<TypeFromPartialBitSchema<{
                executeIfOff: BitFlag;
            }>>;
            saturation: FieldType<number>;
            transitionTime: FieldType<number>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                enhancedHue: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        enhancedStepHue: Command<TypeFromFields<{
            optionsMask: FieldType<TypeFromPartialBitSchema<{
                executeIfOff: BitFlag;
            }>>;
            optionsOverride: FieldType<TypeFromPartialBitSchema<{
                executeIfOff: BitFlag;
            }>>;
            stepMode: FieldType<ColorControl.StepMode>;
            stepSize: FieldType<number>;
            transitionTime: FieldType<number>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                enhancedHue: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        moveColor: Command<TypeFromFields<{
            optionsMask: FieldType<TypeFromPartialBitSchema<{
                executeIfOff: BitFlag;
            }>>;
            optionsOverride: FieldType<TypeFromPartialBitSchema<{
                executeIfOff: BitFlag;
            }>>;
            rateX: FieldType<number>;
            rateY: FieldType<number>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                xy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        moveColorTemperature: Command<TypeFromFields<{
            colorTemperatureMaximumMireds: FieldType<number>;
            colorTemperatureMinimumMireds: FieldType<number>;
            moveMode: FieldType<ColorControl.MoveMode>;
            optionsMask: FieldType<TypeFromPartialBitSchema<{
                executeIfOff: BitFlag;
            }>>;
            optionsOverride: FieldType<TypeFromPartialBitSchema<{
                executeIfOff: BitFlag;
            }>>;
            rate: FieldType<number>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                colorTemperature: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        moveHue: Command<TypeFromFields<{
            moveMode: FieldType<ColorControl.MoveMode>;
            optionsMask: FieldType<TypeFromPartialBitSchema<{
                executeIfOff: BitFlag;
            }>>;
            optionsOverride: FieldType<TypeFromPartialBitSchema<{
                executeIfOff: BitFlag;
            }>>;
            rate: FieldType<number>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                hueSaturation: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        moveSaturation: Command<TypeFromFields<{
            moveMode: FieldType<ColorControl.MoveMode>;
            optionsMask: FieldType<TypeFromPartialBitSchema<{
                executeIfOff: BitFlag;
            }>>;
            optionsOverride: FieldType<TypeFromPartialBitSchema<{
                executeIfOff: BitFlag;
            }>>;
            rate: FieldType<number>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                hueSaturation: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        moveToColor: Command<TypeFromFields<{
            colorX: FieldType<number>;
            colorY: FieldType<number>;
            optionsMask: FieldType<TypeFromPartialBitSchema<{
                executeIfOff: BitFlag;
            }>>;
            optionsOverride: FieldType<TypeFromPartialBitSchema<{
                executeIfOff: BitFlag;
            }>>;
            transitionTime: FieldType<number>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                xy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        moveToColorTemperature: Command<TypeFromFields<{
            colorTemperatureMireds: FieldType<number>;
            optionsMask: FieldType<TypeFromPartialBitSchema<{
                executeIfOff: BitFlag;
            }>>;
            optionsOverride: FieldType<TypeFromPartialBitSchema<{
                executeIfOff: BitFlag;
            }>>;
            transitionTime: FieldType<number>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                colorTemperature: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        moveToHue: Command<TypeFromFields<{
            direction: FieldType<ColorControl.Direction>;
            hue: FieldType<number>;
            optionsMask: FieldType<TypeFromPartialBitSchema<{
                executeIfOff: BitFlag;
            }>>;
            optionsOverride: FieldType<TypeFromPartialBitSchema<{
                executeIfOff: BitFlag;
            }>>;
            transitionTime: FieldType<number>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                hueSaturation: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        moveToHueAndSaturation: Command<TypeFromFields<{
            hue: FieldType<number>;
            optionsMask: FieldType<TypeFromPartialBitSchema<{
                executeIfOff: BitFlag;
            }>>;
            optionsOverride: FieldType<TypeFromPartialBitSchema<{
                executeIfOff: BitFlag;
            }>>;
            saturation: FieldType<number>;
            transitionTime: FieldType<number>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                hueSaturation: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        moveToSaturation: Command<TypeFromFields<{
            optionsMask: FieldType<TypeFromPartialBitSchema<{
                executeIfOff: BitFlag;
            }>>;
            optionsOverride: FieldType<TypeFromPartialBitSchema<{
                executeIfOff: BitFlag;
            }>>;
            saturation: FieldType<number>;
            transitionTime: FieldType<number>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                hueSaturation: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        stepColor: Command<TypeFromFields<{
            optionsMask: FieldType<TypeFromPartialBitSchema<{
                executeIfOff: BitFlag;
            }>>;
            optionsOverride: FieldType<TypeFromPartialBitSchema<{
                executeIfOff: BitFlag;
            }>>;
            stepX: FieldType<number>;
            stepY: FieldType<number>;
            transitionTime: FieldType<number>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                xy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        stepColorTemperature: Command<TypeFromFields<{
            colorTemperatureMaximumMireds: FieldType<number>;
            colorTemperatureMinimumMireds: FieldType<number>;
            optionsMask: FieldType<TypeFromPartialBitSchema<{
                executeIfOff: BitFlag;
            }>>;
            optionsOverride: FieldType<TypeFromPartialBitSchema<{
                executeIfOff: BitFlag;
            }>>;
            stepMode: FieldType<ColorControl.StepMode>;
            stepSize: FieldType<number>;
            transitionTime: FieldType<number>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                colorTemperature: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        stepHue: Command<TypeFromFields<{
            optionsMask: FieldType<TypeFromPartialBitSchema<{
                executeIfOff: BitFlag;
            }>>;
            optionsOverride: FieldType<TypeFromPartialBitSchema<{
                executeIfOff: BitFlag;
            }>>;
            stepMode: FieldType<ColorControl.StepMode>;
            stepSize: FieldType<number>;
            transitionTime: FieldType<number>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                hueSaturation: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        stepSaturation: Command<TypeFromFields<{
            optionsMask: FieldType<TypeFromPartialBitSchema<{
                executeIfOff: BitFlag;
            }>>;
            optionsOverride: FieldType<TypeFromPartialBitSchema<{
                executeIfOff: BitFlag;
            }>>;
            stepMode: FieldType<ColorControl.StepMode>;
            stepSize: FieldType<number>;
            transitionTime: FieldType<number>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                hueSaturation: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        stopMoveStep: Command<TypeFromFields<{
            optionsMask: FieldType<TypeFromPartialBitSchema<{
                executeIfOff: BitFlag;
            }>>;
            optionsOverride: FieldType<TypeFromPartialBitSchema<{
                executeIfOff: BitFlag;
            }>>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                hueSaturation: boolean;
            }, {
                xy: boolean;
            }, {
                colorTemperature: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    events: {};
    extensions: undefined;
    features: {
        colorLoop: BitFlag;
        colorTemperature: BitFlag;
        enhancedHue: BitFlag;
        hueSaturation: BitFlag;
        xy: BitFlag;
    };
    id: Branded<Branded<768, "ClusterId">, "ClusterId">;
    name: "ColorControl";
    revision: 6;
    supportedFeatures: {};
    unknown: false;
    alter<const AlterationsT>(alterations: AlterationsT): WithAlterations<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            clusterRevision: Attribute<number, never>;
            colorCapabilities: Attribute<TypeFromPartialBitSchema<{
                colorLoop: BitFlag;
                colorTemperature: BitFlag;
                enhancedHue: BitFlag;
                hueSaturation: BitFlag;
                xy: BitFlag;
            }>, any>;
            colorLoopActive: Attribute<ColorControl.ColorLoopActive, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    colorLoop: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            colorLoopDirection: Attribute<ColorControl.ColorLoopDirection, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    colorLoop: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            colorLoopStartEnhancedHue: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    colorLoop: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            colorLoopStoredEnhancedHue: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    colorLoop: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            colorLoopTime: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    colorLoop: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            colorMode: Attribute<ColorControl.ColorMode, any>;
            colorPointBIntensity: OptionalWritableAttribute<null | number, any>;
            colorPointBx: OptionalWritableAttribute<number, any>;
            colorPointBy: OptionalWritableAttribute<number, any>;
            colorPointGIntensity: OptionalWritableAttribute<null | number, any>;
            colorPointGx: OptionalWritableAttribute<number, any>;
            colorPointGy: OptionalWritableAttribute<number, any>;
            colorPointRIntensity: OptionalWritableAttribute<null | number, any>;
            colorPointRx: OptionalWritableAttribute<number, any>;
            colorPointRy: OptionalWritableAttribute<number, any>;
            colorTemperatureMireds: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    colorTemperature: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            colorTempPhysicalMaxMireds: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    colorTemperature: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            colorTempPhysicalMinMireds: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    colorTemperature: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            compensationText: OptionalAttribute<string, any>;
            coupleColorTempToLevelMinMireds: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    colorTemperature: boolean;
                }];
            };
            currentHue: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    hueSaturation: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            currentSaturation: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    hueSaturation: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            currentX: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    xy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            currentY: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    xy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            driftCompensation: OptionalAttribute<ColorControl.DriftCompensation, any>;
            enhancedColorMode: Attribute<ColorControl.EnhancedColorMode, any>;
            enhancedCurrentHue: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    enhancedHue: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            featureMap: Attribute<TypeFromPartialBitSchema<{
                colorLoop: BitFlag;
                colorTemperature: BitFlag;
                enhancedHue: BitFlag;
                hueSaturation: BitFlag;
                xy: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            numberOfPrimaries: FixedAttribute<null | number, any>;
            options: WritableAttribute<TypeFromPartialBitSchema<{
                executeIfOff: BitFlag;
            }>, any>;
            primary1Intensity: OptionalFixedAttribute<null | number, any>;
            primary1X: OptionalFixedAttribute<number, any>;
            primary1Y: OptionalFixedAttribute<number, any>;
            primary2Intensity: OptionalFixedAttribute<null | number, any>;
            primary2X: OptionalFixedAttribute<number, any>;
            primary2Y: OptionalFixedAttribute<number, any>;
            primary3Intensity: OptionalFixedAttribute<null | number, any>;
            primary3X: OptionalFixedAttribute<number, any>;
            primary3Y: OptionalFixedAttribute<number, any>;
            primary4Intensity: OptionalFixedAttribute<null | number, any>;
            primary4X: OptionalFixedAttribute<number, any>;
            primary4Y: OptionalFixedAttribute<number, any>;
            primary5Intensity: OptionalFixedAttribute<null | number, any>;
            primary5X: OptionalFixedAttribute<number, any>;
            primary5Y: OptionalFixedAttribute<number, any>;
            primary6Intensity: OptionalFixedAttribute<null | number, any>;
            primary6X: OptionalFixedAttribute<number, any>;
            primary6Y: OptionalFixedAttribute<number, any>;
            remainingTime: OptionalAttribute<number, any>;
            startUpColorTemperatureMireds: OptionalWritableAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    colorTemperature: boolean;
                }];
            };
            whitePointX: OptionalWritableAttribute<number, any>;
            whitePointY: OptionalWritableAttribute<number, any>;
        };
        commands: {
            colorLoopSet: Command<TypeFromFields<{
                action: FieldType<ColorControl.Action>;
                direction: FieldType<ColorControl.ColorLoopSetDirection>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                startHue: FieldType<number>;
                time: FieldType<number>;
                updateFlags: FieldType<TypeFromPartialBitSchema<{
                    reserved: ...;
                    updateAction: ...;
                    updateDirection: ...;
                    updateStartHue: ...;
                    updateTime: ...;
                }>>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    colorLoop: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            enhancedMoveHue: Command<TypeFromFields<{
                moveMode: FieldType<ColorControl.MoveMode>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                rate: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    enhancedHue: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            enhancedMoveToHue: Command<TypeFromFields<{
                direction: FieldType<ColorControl.Direction>;
                enhancedHue: FieldType<number>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                transitionTime: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    enhancedHue: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            enhancedMoveToHueAndSaturation: Command<TypeFromFields<{
                enhancedHue: FieldType<number>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                saturation: FieldType<number>;
                transitionTime: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    enhancedHue: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            enhancedStepHue: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                stepMode: FieldType<ColorControl.StepMode>;
                stepSize: FieldType<number>;
                transitionTime: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    enhancedHue: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            moveColor: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                rateX: FieldType<number>;
                rateY: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    xy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            moveColorTemperature: Command<TypeFromFields<{
                colorTemperatureMaximumMireds: FieldType<number>;
                colorTemperatureMinimumMireds: FieldType<number>;
                moveMode: FieldType<ColorControl.MoveMode>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                rate: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    colorTemperature: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            moveHue: Command<TypeFromFields<{
                moveMode: FieldType<ColorControl.MoveMode>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                rate: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    hueSaturation: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            moveSaturation: Command<TypeFromFields<{
                moveMode: FieldType<ColorControl.MoveMode>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                rate: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    hueSaturation: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            moveToColor: Command<TypeFromFields<{
                colorX: FieldType<number>;
                colorY: FieldType<number>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                transitionTime: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    xy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            moveToColorTemperature: Command<TypeFromFields<{
                colorTemperatureMireds: FieldType<number>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                transitionTime: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    colorTemperature: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            moveToHue: Command<TypeFromFields<{
                direction: FieldType<ColorControl.Direction>;
                hue: FieldType<number>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                transitionTime: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    hueSaturation: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            moveToHueAndSaturation: Command<TypeFromFields<{
                hue: FieldType<number>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                saturation: FieldType<number>;
                transitionTime: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    hueSaturation: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            moveToSaturation: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                saturation: FieldType<number>;
                transitionTime: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    hueSaturation: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            stepColor: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                stepX: FieldType<number>;
                stepY: FieldType<number>;
                transitionTime: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    xy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            stepColorTemperature: Command<TypeFromFields<{
                colorTemperatureMaximumMireds: FieldType<number>;
                colorTemperatureMinimumMireds: FieldType<number>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                stepMode: FieldType<ColorControl.StepMode>;
                stepSize: FieldType<number>;
                transitionTime: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    colorTemperature: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            stepHue: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                stepMode: FieldType<ColorControl.StepMode>;
                stepSize: FieldType<number>;
                transitionTime: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    hueSaturation: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            stepSaturation: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                stepMode: FieldType<ColorControl.StepMode>;
                stepSize: FieldType<number>;
                transitionTime: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    hueSaturation: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            stopMoveStep: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    hueSaturation: boolean;
                }, {
                    xy: boolean;
                }, {
                    colorTemperature: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            colorLoop: BitFlag;
            colorTemperature: BitFlag;
            enhancedHue: BitFlag;
            hueSaturation: BitFlag;
            xy: BitFlag;
        };
        id: Branded<768, "ClusterId">;
        name: "ColorControl";
        revision: 6;
    }>, AlterationsT>;
    enable<const FlagsT>(flags: FlagsT): WithFlags<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            clusterRevision: Attribute<number, never>;
            colorCapabilities: Attribute<TypeFromPartialBitSchema<{
                colorLoop: BitFlag;
                colorTemperature: BitFlag;
                enhancedHue: BitFlag;
                hueSaturation: BitFlag;
                xy: BitFlag;
            }>, any>;
            colorLoopActive: Attribute<ColorControl.ColorLoopActive, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    colorLoop: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            colorLoopDirection: Attribute<ColorControl.ColorLoopDirection, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    colorLoop: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            colorLoopStartEnhancedHue: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    colorLoop: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            colorLoopStoredEnhancedHue: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    colorLoop: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            colorLoopTime: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    colorLoop: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            colorMode: Attribute<ColorControl.ColorMode, any>;
            colorPointBIntensity: OptionalWritableAttribute<null | number, any>;
            colorPointBx: OptionalWritableAttribute<number, any>;
            colorPointBy: OptionalWritableAttribute<number, any>;
            colorPointGIntensity: OptionalWritableAttribute<null | number, any>;
            colorPointGx: OptionalWritableAttribute<number, any>;
            colorPointGy: OptionalWritableAttribute<number, any>;
            colorPointRIntensity: OptionalWritableAttribute<null | number, any>;
            colorPointRx: OptionalWritableAttribute<number, any>;
            colorPointRy: OptionalWritableAttribute<number, any>;
            colorTemperatureMireds: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    colorTemperature: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            colorTempPhysicalMaxMireds: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    colorTemperature: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            colorTempPhysicalMinMireds: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    colorTemperature: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            compensationText: OptionalAttribute<string, any>;
            coupleColorTempToLevelMinMireds: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    colorTemperature: boolean;
                }];
            };
            currentHue: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    hueSaturation: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            currentSaturation: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    hueSaturation: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            currentX: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    xy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            currentY: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    xy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            driftCompensation: OptionalAttribute<ColorControl.DriftCompensation, any>;
            enhancedColorMode: Attribute<ColorControl.EnhancedColorMode, any>;
            enhancedCurrentHue: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    enhancedHue: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            featureMap: Attribute<TypeFromPartialBitSchema<{
                colorLoop: BitFlag;
                colorTemperature: BitFlag;
                enhancedHue: BitFlag;
                hueSaturation: BitFlag;
                xy: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            numberOfPrimaries: FixedAttribute<null | number, any>;
            options: WritableAttribute<TypeFromPartialBitSchema<{
                executeIfOff: BitFlag;
            }>, any>;
            primary1Intensity: OptionalFixedAttribute<null | number, any>;
            primary1X: OptionalFixedAttribute<number, any>;
            primary1Y: OptionalFixedAttribute<number, any>;
            primary2Intensity: OptionalFixedAttribute<null | number, any>;
            primary2X: OptionalFixedAttribute<number, any>;
            primary2Y: OptionalFixedAttribute<number, any>;
            primary3Intensity: OptionalFixedAttribute<null | number, any>;
            primary3X: OptionalFixedAttribute<number, any>;
            primary3Y: OptionalFixedAttribute<number, any>;
            primary4Intensity: OptionalFixedAttribute<null | number, any>;
            primary4X: OptionalFixedAttribute<number, any>;
            primary4Y: OptionalFixedAttribute<number, any>;
            primary5Intensity: OptionalFixedAttribute<null | number, any>;
            primary5X: OptionalFixedAttribute<number, any>;
            primary5Y: OptionalFixedAttribute<number, any>;
            primary6Intensity: OptionalFixedAttribute<null | number, any>;
            primary6X: OptionalFixedAttribute<number, any>;
            primary6Y: OptionalFixedAttribute<number, any>;
            remainingTime: OptionalAttribute<number, any>;
            startUpColorTemperatureMireds: OptionalWritableAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    colorTemperature: boolean;
                }];
            };
            whitePointX: OptionalWritableAttribute<number, any>;
            whitePointY: OptionalWritableAttribute<number, any>;
        };
        commands: {
            colorLoopSet: Command<TypeFromFields<{
                action: FieldType<ColorControl.Action>;
                direction: FieldType<ColorControl.ColorLoopSetDirection>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                startHue: FieldType<number>;
                time: FieldType<number>;
                updateFlags: FieldType<TypeFromPartialBitSchema<{
                    reserved: ...;
                    updateAction: ...;
                    updateDirection: ...;
                    updateStartHue: ...;
                    updateTime: ...;
                }>>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    colorLoop: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            enhancedMoveHue: Command<TypeFromFields<{
                moveMode: FieldType<ColorControl.MoveMode>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                rate: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    enhancedHue: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            enhancedMoveToHue: Command<TypeFromFields<{
                direction: FieldType<ColorControl.Direction>;
                enhancedHue: FieldType<number>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                transitionTime: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    enhancedHue: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            enhancedMoveToHueAndSaturation: Command<TypeFromFields<{
                enhancedHue: FieldType<number>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                saturation: FieldType<number>;
                transitionTime: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    enhancedHue: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            enhancedStepHue: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                stepMode: FieldType<ColorControl.StepMode>;
                stepSize: FieldType<number>;
                transitionTime: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    enhancedHue: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            moveColor: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                rateX: FieldType<number>;
                rateY: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    xy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            moveColorTemperature: Command<TypeFromFields<{
                colorTemperatureMaximumMireds: FieldType<number>;
                colorTemperatureMinimumMireds: FieldType<number>;
                moveMode: FieldType<ColorControl.MoveMode>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                rate: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    colorTemperature: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            moveHue: Command<TypeFromFields<{
                moveMode: FieldType<ColorControl.MoveMode>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                rate: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    hueSaturation: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            moveSaturation: Command<TypeFromFields<{
                moveMode: FieldType<ColorControl.MoveMode>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                rate: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    hueSaturation: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            moveToColor: Command<TypeFromFields<{
                colorX: FieldType<number>;
                colorY: FieldType<number>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                transitionTime: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    xy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            moveToColorTemperature: Command<TypeFromFields<{
                colorTemperatureMireds: FieldType<number>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                transitionTime: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    colorTemperature: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            moveToHue: Command<TypeFromFields<{
                direction: FieldType<ColorControl.Direction>;
                hue: FieldType<number>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                transitionTime: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    hueSaturation: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            moveToHueAndSaturation: Command<TypeFromFields<{
                hue: FieldType<number>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                saturation: FieldType<number>;
                transitionTime: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    hueSaturation: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            moveToSaturation: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                saturation: FieldType<number>;
                transitionTime: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    hueSaturation: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            stepColor: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                stepX: FieldType<number>;
                stepY: FieldType<number>;
                transitionTime: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    xy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            stepColorTemperature: Command<TypeFromFields<{
                colorTemperatureMaximumMireds: FieldType<number>;
                colorTemperatureMinimumMireds: FieldType<number>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                stepMode: FieldType<ColorControl.StepMode>;
                stepSize: FieldType<number>;
                transitionTime: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    colorTemperature: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            stepHue: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                stepMode: FieldType<ColorControl.StepMode>;
                stepSize: FieldType<number>;
                transitionTime: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    hueSaturation: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            stepSaturation: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                stepMode: FieldType<ColorControl.StepMode>;
                stepSize: FieldType<number>;
                transitionTime: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    hueSaturation: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            stopMoveStep: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    hueSaturation: boolean;
                }, {
                    xy: boolean;
                }, {
                    colorTemperature: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            colorLoop: BitFlag;
            colorTemperature: BitFlag;
            enhancedHue: BitFlag;
            hueSaturation: BitFlag;
            xy: BitFlag;
        };
        id: Branded<768, "ClusterId">;
        name: "ColorControl";
        revision: 6;
    }>, FlagsT>;
    set<const ValuesT>(values: ValuesT): WithValues<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            clusterRevision: Attribute<number, never>;
            colorCapabilities: Attribute<TypeFromPartialBitSchema<{
                colorLoop: BitFlag;
                colorTemperature: BitFlag;
                enhancedHue: BitFlag;
                hueSaturation: BitFlag;
                xy: BitFlag;
            }>, any>;
            colorLoopActive: Attribute<ColorControl.ColorLoopActive, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    colorLoop: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            colorLoopDirection: Attribute<ColorControl.ColorLoopDirection, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    colorLoop: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            colorLoopStartEnhancedHue: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    colorLoop: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            colorLoopStoredEnhancedHue: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    colorLoop: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            colorLoopTime: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    colorLoop: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            colorMode: Attribute<ColorControl.ColorMode, any>;
            colorPointBIntensity: OptionalWritableAttribute<null | number, any>;
            colorPointBx: OptionalWritableAttribute<number, any>;
            colorPointBy: OptionalWritableAttribute<number, any>;
            colorPointGIntensity: OptionalWritableAttribute<null | number, any>;
            colorPointGx: OptionalWritableAttribute<number, any>;
            colorPointGy: OptionalWritableAttribute<number, any>;
            colorPointRIntensity: OptionalWritableAttribute<null | number, any>;
            colorPointRx: OptionalWritableAttribute<number, any>;
            colorPointRy: OptionalWritableAttribute<number, any>;
            colorTemperatureMireds: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    colorTemperature: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            colorTempPhysicalMaxMireds: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    colorTemperature: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            colorTempPhysicalMinMireds: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    colorTemperature: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            compensationText: OptionalAttribute<string, any>;
            coupleColorTempToLevelMinMireds: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    colorTemperature: boolean;
                }];
            };
            currentHue: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    hueSaturation: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            currentSaturation: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    hueSaturation: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            currentX: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    xy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            currentY: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    xy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            driftCompensation: OptionalAttribute<ColorControl.DriftCompensation, any>;
            enhancedColorMode: Attribute<ColorControl.EnhancedColorMode, any>;
            enhancedCurrentHue: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    enhancedHue: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            featureMap: Attribute<TypeFromPartialBitSchema<{
                colorLoop: BitFlag;
                colorTemperature: BitFlag;
                enhancedHue: BitFlag;
                hueSaturation: BitFlag;
                xy: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            numberOfPrimaries: FixedAttribute<null | number, any>;
            options: WritableAttribute<TypeFromPartialBitSchema<{
                executeIfOff: BitFlag;
            }>, any>;
            primary1Intensity: OptionalFixedAttribute<null | number, any>;
            primary1X: OptionalFixedAttribute<number, any>;
            primary1Y: OptionalFixedAttribute<number, any>;
            primary2Intensity: OptionalFixedAttribute<null | number, any>;
            primary2X: OptionalFixedAttribute<number, any>;
            primary2Y: OptionalFixedAttribute<number, any>;
            primary3Intensity: OptionalFixedAttribute<null | number, any>;
            primary3X: OptionalFixedAttribute<number, any>;
            primary3Y: OptionalFixedAttribute<number, any>;
            primary4Intensity: OptionalFixedAttribute<null | number, any>;
            primary4X: OptionalFixedAttribute<number, any>;
            primary4Y: OptionalFixedAttribute<number, any>;
            primary5Intensity: OptionalFixedAttribute<null | number, any>;
            primary5X: OptionalFixedAttribute<number, any>;
            primary5Y: OptionalFixedAttribute<number, any>;
            primary6Intensity: OptionalFixedAttribute<null | number, any>;
            primary6X: OptionalFixedAttribute<number, any>;
            primary6Y: OptionalFixedAttribute<number, any>;
            remainingTime: OptionalAttribute<number, any>;
            startUpColorTemperatureMireds: OptionalWritableAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    colorTemperature: boolean;
                }];
            };
            whitePointX: OptionalWritableAttribute<number, any>;
            whitePointY: OptionalWritableAttribute<number, any>;
        };
        commands: {
            colorLoopSet: Command<TypeFromFields<{
                action: FieldType<ColorControl.Action>;
                direction: FieldType<ColorControl.ColorLoopSetDirection>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                startHue: FieldType<number>;
                time: FieldType<number>;
                updateFlags: FieldType<TypeFromPartialBitSchema<{
                    reserved: ...;
                    updateAction: ...;
                    updateDirection: ...;
                    updateStartHue: ...;
                    updateTime: ...;
                }>>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    colorLoop: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            enhancedMoveHue: Command<TypeFromFields<{
                moveMode: FieldType<ColorControl.MoveMode>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                rate: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    enhancedHue: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            enhancedMoveToHue: Command<TypeFromFields<{
                direction: FieldType<ColorControl.Direction>;
                enhancedHue: FieldType<number>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                transitionTime: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    enhancedHue: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            enhancedMoveToHueAndSaturation: Command<TypeFromFields<{
                enhancedHue: FieldType<number>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                saturation: FieldType<number>;
                transitionTime: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    enhancedHue: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            enhancedStepHue: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                stepMode: FieldType<ColorControl.StepMode>;
                stepSize: FieldType<number>;
                transitionTime: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    enhancedHue: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            moveColor: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                rateX: FieldType<number>;
                rateY: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    xy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            moveColorTemperature: Command<TypeFromFields<{
                colorTemperatureMaximumMireds: FieldType<number>;
                colorTemperatureMinimumMireds: FieldType<number>;
                moveMode: FieldType<ColorControl.MoveMode>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                rate: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    colorTemperature: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            moveHue: Command<TypeFromFields<{
                moveMode: FieldType<ColorControl.MoveMode>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                rate: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    hueSaturation: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            moveSaturation: Command<TypeFromFields<{
                moveMode: FieldType<ColorControl.MoveMode>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                rate: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    hueSaturation: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            moveToColor: Command<TypeFromFields<{
                colorX: FieldType<number>;
                colorY: FieldType<number>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                transitionTime: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    xy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            moveToColorTemperature: Command<TypeFromFields<{
                colorTemperatureMireds: FieldType<number>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                transitionTime: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    colorTemperature: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            moveToHue: Command<TypeFromFields<{
                direction: FieldType<ColorControl.Direction>;
                hue: FieldType<number>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                transitionTime: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    hueSaturation: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            moveToHueAndSaturation: Command<TypeFromFields<{
                hue: FieldType<number>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                saturation: FieldType<number>;
                transitionTime: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    hueSaturation: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            moveToSaturation: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                saturation: FieldType<number>;
                transitionTime: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    hueSaturation: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            stepColor: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                stepX: FieldType<number>;
                stepY: FieldType<number>;
                transitionTime: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    xy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            stepColorTemperature: Command<TypeFromFields<{
                colorTemperatureMaximumMireds: FieldType<number>;
                colorTemperatureMinimumMireds: FieldType<number>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                stepMode: FieldType<ColorControl.StepMode>;
                stepSize: FieldType<number>;
                transitionTime: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    colorTemperature: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            stepHue: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                stepMode: FieldType<ColorControl.StepMode>;
                stepSize: FieldType<number>;
                transitionTime: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    hueSaturation: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            stepSaturation: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                stepMode: FieldType<ColorControl.StepMode>;
                stepSize: FieldType<number>;
                transitionTime: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    hueSaturation: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            stopMoveStep: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    hueSaturation: boolean;
                }, {
                    xy: boolean;
                }, {
                    colorTemperature: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            colorLoop: BitFlag;
            colorTemperature: BitFlag;
            enhancedHue: BitFlag;
            hueSaturation: BitFlag;
            xy: BitFlag;
        };
        id: Branded<768, "ClusterId">;
        name: "ColorControl";
        revision: 6;
    }>, ValuesT>;
    with<const SelectionT>(...selection: SelectionT): Of<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            clusterRevision: Attribute<number, never>;
            colorCapabilities: Attribute<TypeFromPartialBitSchema<{
                colorLoop: BitFlag;
                colorTemperature: BitFlag;
                enhancedHue: BitFlag;
                hueSaturation: BitFlag;
                xy: BitFlag;
            }>, any>;
            colorLoopActive: Attribute<ColorControl.ColorLoopActive, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    colorLoop: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            colorLoopDirection: Attribute<ColorControl.ColorLoopDirection, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    colorLoop: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            colorLoopStartEnhancedHue: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    colorLoop: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            colorLoopStoredEnhancedHue: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    colorLoop: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            colorLoopTime: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    colorLoop: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            colorMode: Attribute<ColorControl.ColorMode, any>;
            colorPointBIntensity: OptionalWritableAttribute<null | number, any>;
            colorPointBx: OptionalWritableAttribute<number, any>;
            colorPointBy: OptionalWritableAttribute<number, any>;
            colorPointGIntensity: OptionalWritableAttribute<null | number, any>;
            colorPointGx: OptionalWritableAttribute<number, any>;
            colorPointGy: OptionalWritableAttribute<number, any>;
            colorPointRIntensity: OptionalWritableAttribute<null | number, any>;
            colorPointRx: OptionalWritableAttribute<number, any>;
            colorPointRy: OptionalWritableAttribute<number, any>;
            colorTemperatureMireds: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    colorTemperature: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            colorTempPhysicalMaxMireds: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    colorTemperature: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            colorTempPhysicalMinMireds: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    colorTemperature: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            compensationText: OptionalAttribute<string, any>;
            coupleColorTempToLevelMinMireds: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    colorTemperature: boolean;
                }];
            };
            currentHue: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    hueSaturation: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            currentSaturation: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    hueSaturation: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            currentX: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    xy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            currentY: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    xy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            driftCompensation: OptionalAttribute<ColorControl.DriftCompensation, any>;
            enhancedColorMode: Attribute<ColorControl.EnhancedColorMode, any>;
            enhancedCurrentHue: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    enhancedHue: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            featureMap: Attribute<TypeFromPartialBitSchema<{
                colorLoop: BitFlag;
                colorTemperature: BitFlag;
                enhancedHue: BitFlag;
                hueSaturation: BitFlag;
                xy: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            numberOfPrimaries: FixedAttribute<null | number, any>;
            options: WritableAttribute<TypeFromPartialBitSchema<{
                executeIfOff: BitFlag;
            }>, any>;
            primary1Intensity: OptionalFixedAttribute<null | number, any>;
            primary1X: OptionalFixedAttribute<number, any>;
            primary1Y: OptionalFixedAttribute<number, any>;
            primary2Intensity: OptionalFixedAttribute<null | number, any>;
            primary2X: OptionalFixedAttribute<number, any>;
            primary2Y: OptionalFixedAttribute<number, any>;
            primary3Intensity: OptionalFixedAttribute<null | number, any>;
            primary3X: OptionalFixedAttribute<number, any>;
            primary3Y: OptionalFixedAttribute<number, any>;
            primary4Intensity: OptionalFixedAttribute<null | number, any>;
            primary4X: OptionalFixedAttribute<number, any>;
            primary4Y: OptionalFixedAttribute<number, any>;
            primary5Intensity: OptionalFixedAttribute<null | number, any>;
            primary5X: OptionalFixedAttribute<number, any>;
            primary5Y: OptionalFixedAttribute<number, any>;
            primary6Intensity: OptionalFixedAttribute<null | number, any>;
            primary6X: OptionalFixedAttribute<number, any>;
            primary6Y: OptionalFixedAttribute<number, any>;
            remainingTime: OptionalAttribute<number, any>;
            startUpColorTemperatureMireds: OptionalWritableAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    colorTemperature: boolean;
                }];
            };
            whitePointX: OptionalWritableAttribute<number, any>;
            whitePointY: OptionalWritableAttribute<number, any>;
        };
        commands: {
            colorLoopSet: Command<TypeFromFields<{
                action: FieldType<ColorControl.Action>;
                direction: FieldType<ColorControl.ColorLoopSetDirection>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                startHue: FieldType<number>;
                time: FieldType<number>;
                updateFlags: FieldType<TypeFromPartialBitSchema<{
                    reserved: ...;
                    updateAction: ...;
                    updateDirection: ...;
                    updateStartHue: ...;
                    updateTime: ...;
                }>>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    colorLoop: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            enhancedMoveHue: Command<TypeFromFields<{
                moveMode: FieldType<ColorControl.MoveMode>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                rate: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    enhancedHue: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            enhancedMoveToHue: Command<TypeFromFields<{
                direction: FieldType<ColorControl.Direction>;
                enhancedHue: FieldType<number>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                transitionTime: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    enhancedHue: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            enhancedMoveToHueAndSaturation: Command<TypeFromFields<{
                enhancedHue: FieldType<number>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                saturation: FieldType<number>;
                transitionTime: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    enhancedHue: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            enhancedStepHue: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                stepMode: FieldType<ColorControl.StepMode>;
                stepSize: FieldType<number>;
                transitionTime: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    enhancedHue: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            moveColor: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                rateX: FieldType<number>;
                rateY: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    xy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            moveColorTemperature: Command<TypeFromFields<{
                colorTemperatureMaximumMireds: FieldType<number>;
                colorTemperatureMinimumMireds: FieldType<number>;
                moveMode: FieldType<ColorControl.MoveMode>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                rate: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    colorTemperature: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            moveHue: Command<TypeFromFields<{
                moveMode: FieldType<ColorControl.MoveMode>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                rate: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    hueSaturation: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            moveSaturation: Command<TypeFromFields<{
                moveMode: FieldType<ColorControl.MoveMode>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                rate: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    hueSaturation: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            moveToColor: Command<TypeFromFields<{
                colorX: FieldType<number>;
                colorY: FieldType<number>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                transitionTime: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    xy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            moveToColorTemperature: Command<TypeFromFields<{
                colorTemperatureMireds: FieldType<number>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                transitionTime: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    colorTemperature: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            moveToHue: Command<TypeFromFields<{
                direction: FieldType<ColorControl.Direction>;
                hue: FieldType<number>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                transitionTime: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    hueSaturation: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            moveToHueAndSaturation: Command<TypeFromFields<{
                hue: FieldType<number>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                saturation: FieldType<number>;
                transitionTime: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    hueSaturation: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            moveToSaturation: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                saturation: FieldType<number>;
                transitionTime: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    hueSaturation: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            stepColor: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                stepX: FieldType<number>;
                stepY: FieldType<number>;
                transitionTime: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    xy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            stepColorTemperature: Command<TypeFromFields<{
                colorTemperatureMaximumMireds: FieldType<number>;
                colorTemperatureMinimumMireds: FieldType<number>;
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                stepMode: FieldType<ColorControl.StepMode>;
                stepSize: FieldType<number>;
                transitionTime: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    colorTemperature: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            stepHue: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                stepMode: FieldType<ColorControl.StepMode>;
                stepSize: FieldType<number>;
                transitionTime: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    hueSaturation: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            stepSaturation: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                stepMode: FieldType<ColorControl.StepMode>;
                stepSize: FieldType<number>;
                transitionTime: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    hueSaturation: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            stopMoveStep: Command<TypeFromFields<{
                optionsMask: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
                optionsOverride: FieldType<TypeFromPartialBitSchema<{
                    executeIfOff: ...;
                }>>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    hueSaturation: boolean;
                }, {
                    xy: boolean;
                }, {
                    colorTemperature: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            colorLoop: BitFlag;
            colorTemperature: BitFlag;
            enhancedHue: BitFlag;
            hueSaturation: BitFlag;
            xy: BitFlag;
        };
        id: Branded<768, "ClusterId">;
        name: "ColorControl";
        revision: 6;
    }>, SelectionT>;
}