Variable CompleteInstanceConst

Type declaration

• Readonlyattributes: {
      acceptedCommandList: Attribute<.[], never>;
      attributeList: Attribute<.[], never>;
      clusterRevision: Attribute<number, never>;
      colorCapabilities: Attribute<TypeFromPartialBitSchema, any>;
      colorLoopActive: Attribute<ColorControl.ColorLoopActive, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              colorLoop: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      colorLoopDirection: Attribute<ColorControl.ColorLoopDirection, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              colorLoop: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      colorLoopStartEnhancedHue: Attribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              colorLoop: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      colorLoopStoredEnhancedHue: Attribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              colorLoop: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      colorLoopTime: Attribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              colorLoop: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      colorMode: Attribute<ColorControl.ColorMode, any>;
      colorPointBIntensity: OptionalWritableAttribute<number | null, any>;
      colorPointBx: OptionalWritableAttribute<number, any>;
      colorPointBy: OptionalWritableAttribute<number, any>;
      colorPointGIntensity: OptionalWritableAttribute<number | null, any>;
      colorPointGx: OptionalWritableAttribute<number, any>;
      colorPointGy: OptionalWritableAttribute<number, any>;
      colorPointRIntensity: OptionalWritableAttribute<number | null, any>;
      colorPointRx: OptionalWritableAttribute<number, any>;
      colorPointRy: OptionalWritableAttribute<number, any>;
      colorTemperatureMireds: Attribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              colorTemperature: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      colorTempPhysicalMaxMireds: Attribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              colorTemperature: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      colorTempPhysicalMinMireds: Attribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              colorTemperature: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      compensationText: OptionalAttribute<string, any>;
      coupleColorTempToLevelMinMireds: OptionalAttribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              colorTemperature: boolean;
          }];
      };
      currentHue: Attribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              hueSaturation: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      currentSaturation: Attribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              hueSaturation: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      currentX: Attribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              xy: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      currentY: Attribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              xy: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      driftCompensation: OptionalAttribute<ColorControl.DriftCompensation, any>;
      enhancedColorMode: Attribute<ColorControl.EnhancedColorMode, any>;
      enhancedCurrentHue: Attribute<number, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              enhancedHue: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      featureMap: Attribute<TypeFromPartialBitSchema, never>;
      generatedCommandList: Attribute<.[], never>;
      numberOfPrimaries: FixedAttribute<number | null, any>;
      options: WritableAttribute<TypeFromPartialBitSchema, any>;
      primary1Intensity: OptionalFixedAttribute<number | null, any>;
      primary1X: OptionalFixedAttribute<number, any>;
      primary1Y: OptionalFixedAttribute<number, any>;
      primary2Intensity: OptionalFixedAttribute<number | null, any>;
      primary2X: OptionalFixedAttribute<number, any>;
      primary2Y: OptionalFixedAttribute<number, any>;
      primary3Intensity: OptionalFixedAttribute<number | null, any>;
      primary3X: OptionalFixedAttribute<number, any>;
      primary3Y: OptionalFixedAttribute<number, any>;
      primary4Intensity: OptionalFixedAttribute<number | null, any>;
      primary4X: OptionalFixedAttribute<number, any>;
      primary4Y: OptionalFixedAttribute<number, any>;
      primary5Intensity: OptionalFixedAttribute<number | null, any>;
      primary5X: OptionalFixedAttribute<number, any>;
      primary5Y: OptionalFixedAttribute<number, any>;
      primary6Intensity: OptionalFixedAttribute<number | null, any>;
      primary6X: OptionalFixedAttribute<number, any>;
      primary6Y: OptionalFixedAttribute<number, any>;
      remainingTime: OptionalAttribute<number, any>;
      startUpColorTemperatureMireds: OptionalWritableAttribute<number | null, any> & {
          isConditional: true;
          mandatoryIf: [] | ConditionalFeatureList;
          optional: true;
          optionalIf: [] | [{
              colorTemperature: boolean;
          }];
      };
      whitePointX: OptionalWritableAttribute<number, any>;
      whitePointY: OptionalWritableAttribute<number, any>;
  }

  • ReadonlyacceptedCommandList: Attribute<.[], never>

  • ReadonlyattributeList: Attribute<.[], never>

  • ReadonlyclusterRevision: Attribute<number, never>

  • ReadonlycolorCapabilities: Attribute<TypeFromPartialBitSchema, any>

  • ReadonlycolorLoopActive: Attribute<ColorControl.ColorLoopActive, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            colorLoop: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlycolorLoopDirection: Attribute<ColorControl.ColorLoopDirection, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            colorLoop: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlycolorLoopStartEnhancedHue: Attribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            colorLoop: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlycolorLoopStoredEnhancedHue: Attribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            colorLoop: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlycolorLoopTime: Attribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            colorLoop: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlycolorMode: Attribute<ColorControl.ColorMode, any>

  • ReadonlycolorPointBIntensity: OptionalWritableAttribute<number | null, any>

  • ReadonlycolorPointBx: OptionalWritableAttribute<number, any>

  • ReadonlycolorPointBy: OptionalWritableAttribute<number, any>

  • ReadonlycolorPointGIntensity: OptionalWritableAttribute<number | null, any>

  • ReadonlycolorPointGx: OptionalWritableAttribute<number, any>

  • ReadonlycolorPointGy: OptionalWritableAttribute<number, any>

  • ReadonlycolorPointRIntensity: OptionalWritableAttribute<number | null, any>

  • ReadonlycolorPointRx: OptionalWritableAttribute<number, any>

  • ReadonlycolorPointRy: OptionalWritableAttribute<number, any>

  • ReadonlycolorTemperatureMireds: Attribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            colorTemperature: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlycolorTempPhysicalMaxMireds: Attribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            colorTemperature: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlycolorTempPhysicalMinMireds: Attribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            colorTemperature: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlycompensationText: OptionalAttribute<string, any>

  • ReadonlycoupleColorTempToLevelMinMireds: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            colorTemperature: boolean;
        }];
    }

  • ReadonlycurrentHue: Attribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            hueSaturation: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlycurrentSaturation: Attribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            hueSaturation: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlycurrentX: Attribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            xy: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlycurrentY: Attribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            xy: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlydriftCompensation: OptionalAttribute<ColorControl.DriftCompensation, any>

  • ReadonlyenhancedColorMode: Attribute<ColorControl.EnhancedColorMode, any>

  • ReadonlyenhancedCurrentHue: Attribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            enhancedHue: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlyfeatureMap: Attribute<TypeFromPartialBitSchema, never>

  • ReadonlygeneratedCommandList: Attribute<.[], never>

  • ReadonlynumberOfPrimaries: FixedAttribute<number | null, any>

  • Readonlyoptions: WritableAttribute<TypeFromPartialBitSchema, any>

  • Readonlyprimary1Intensity: OptionalFixedAttribute<number | null, any>

  • Readonlyprimary1X: OptionalFixedAttribute<number, any>

  • Readonlyprimary1Y: OptionalFixedAttribute<number, any>

  • Readonlyprimary2Intensity: OptionalFixedAttribute<number | null, any>

  • Readonlyprimary2X: OptionalFixedAttribute<number, any>

  • Readonlyprimary2Y: OptionalFixedAttribute<number, any>

  • Readonlyprimary3Intensity: OptionalFixedAttribute<number | null, any>

  • Readonlyprimary3X: OptionalFixedAttribute<number, any>

  • Readonlyprimary3Y: OptionalFixedAttribute<number, any>

  • Readonlyprimary4Intensity: OptionalFixedAttribute<number | null, any>

  • Readonlyprimary4X: OptionalFixedAttribute<number, any>

  • Readonlyprimary4Y: OptionalFixedAttribute<number, any>

  • Readonlyprimary5Intensity: OptionalFixedAttribute<number | null, any>

  • Readonlyprimary5X: OptionalFixedAttribute<number, any>

  • Readonlyprimary5Y: OptionalFixedAttribute<number, any>

  • Readonlyprimary6Intensity: OptionalFixedAttribute<number | null, any>

  • Readonlyprimary6X: OptionalFixedAttribute<number, any>

  • Readonlyprimary6Y: OptionalFixedAttribute<number, any>

  • ReadonlyremainingTime: OptionalAttribute<number, any>

  • ReadonlystartUpColorTemperatureMireds: OptionalWritableAttribute<number | null, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList;
        optional: true;
        optionalIf: [] | [{
            colorTemperature: boolean;
        }];
    }

  • ReadonlywhitePointX: OptionalWritableAttribute<number, any>

  • ReadonlywhitePointY: OptionalWritableAttribute<number, any>

• Readonlycommands: {
      colorLoopSet: Command<TypeFromFields, void, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              colorLoop: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      enhancedMoveHue: Command<TypeFromFields, void, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              enhancedHue: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      enhancedMoveToHue: Command<TypeFromFields, void, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              enhancedHue: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      enhancedMoveToHueAndSaturation: Command<TypeFromFields, void, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              enhancedHue: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      enhancedStepHue: Command<TypeFromFields, void, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              enhancedHue: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      moveColor: Command<TypeFromFields, void, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              xy: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      moveColorTemperature: Command<TypeFromFields, void, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              colorTemperature: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      moveHue: Command<TypeFromFields, void, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              hueSaturation: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      moveSaturation: Command<TypeFromFields, void, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              hueSaturation: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      moveToColor: Command<TypeFromFields, void, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              xy: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      moveToColorTemperature: Command<TypeFromFields, void, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              colorTemperature: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      moveToHue: Command<TypeFromFields, void, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              hueSaturation: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      moveToHueAndSaturation: Command<TypeFromFields, void, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              hueSaturation: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      moveToSaturation: Command<TypeFromFields, void, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              hueSaturation: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      stepColor: Command<TypeFromFields, void, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              xy: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      stepColorTemperature: Command<TypeFromFields, void, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              colorTemperature: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      stepHue: Command<TypeFromFields, void, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              hueSaturation: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      stepSaturation: Command<TypeFromFields, void, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              hueSaturation: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
      stopMoveStep: Command<TypeFromFields, void, any> & {
          isConditional: true;
          mandatoryIf: [] | [{
              hueSaturation: boolean;
          }, {
              xy: boolean;
          }, {
              colorTemperature: boolean;
          }];
          optional: true;
          optionalIf: [] | ConditionalFeatureList;
      };
  }

  • ReadonlycolorLoopSet: Command<TypeFromFields, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            colorLoop: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlyenhancedMoveHue: Command<TypeFromFields, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            enhancedHue: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlyenhancedMoveToHue: Command<TypeFromFields, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            enhancedHue: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlyenhancedMoveToHueAndSaturation: Command<TypeFromFields, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            enhancedHue: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlyenhancedStepHue: Command<TypeFromFields, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            enhancedHue: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlymoveColor: Command<TypeFromFields, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            xy: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlymoveColorTemperature: Command<TypeFromFields, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            colorTemperature: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlymoveHue: Command<TypeFromFields, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            hueSaturation: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlymoveSaturation: Command<TypeFromFields, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            hueSaturation: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlymoveToColor: Command<TypeFromFields, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            xy: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlymoveToColorTemperature: Command<TypeFromFields, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            colorTemperature: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlymoveToHue: Command<TypeFromFields, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            hueSaturation: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlymoveToHueAndSaturation: Command<TypeFromFields, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            hueSaturation: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlymoveToSaturation: Command<TypeFromFields, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            hueSaturation: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlystepColor: Command<TypeFromFields, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            xy: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlystepColorTemperature: Command<TypeFromFields, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            colorTemperature: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlystepHue: Command<TypeFromFields, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            hueSaturation: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlystepSaturation: Command<TypeFromFields, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            hueSaturation: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

  • ReadonlystopMoveStep: Command<TypeFromFields, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            hueSaturation: boolean;
        }, {
            xy: boolean;
        }, {
            colorTemperature: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList;
    }

• Readonlyfeatures: {
      colorLoop: BitFlag;
      colorTemperature: BitFlag;
      enhancedHue: BitFlag;
      hueSaturation: BitFlag;
      xy: BitFlag;
  }

  • ReadonlycolorLoop: BitFlag

    ColorLoop

    Color loop is supported.

  • ReadonlycolorTemperature: BitFlag

    ColorTemperature

    Supports specification of color temperature.

  • ReadonlyenhancedHue: BitFlag

    EnhancedHue

    Enhanced hue is supported.

  • ReadonlyhueSaturation: BitFlag

    HueSaturation

    Supports color specification via hue/saturation.

  • Readonlyxy: BitFlag

    Xy

    Supports color specification via XY.

• Readonlyid: @matter/general

• Readonlyname: "ColorControl"

• Readonlyrevision: 6