Interface Complete

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

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

interface Complete {
    attributes: Merge<{
        maxTemperature: FixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                temperatureNumber: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        minTemperature: FixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                temperatureNumber: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        selectedTemperatureLevel: Attribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                temperatureLevel: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        step: FixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                temperatureStep: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        supportedTemperatureLevels: Attribute<string[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                temperatureLevel: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        temperatureSetpoint: Attribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                temperatureNumber: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    }, GlobalAttributes<{
        temperatureLevel: BitFlag;
        temperatureNumber: BitFlag;
        temperatureStep: BitFlag;
    }>>;
    base: undefined;
    commands: {
        setTemperature: Command<TypeFromFields<{
            targetTemperature: OptionalFieldType<number>;
            targetTemperatureLevel: OptionalFieldType<number>;
        }>, void, any>;
    };
    events: {};
    extensions: undefined;
    features: {
        temperatureLevel: BitFlag;
        temperatureNumber: BitFlag;
        temperatureStep: BitFlag;
    };
    id: Branded<86, "ClusterId">;
    name: "TemperatureControl";
    revision: 1;
    supportedFeatures: {};
    unknown: false;
    alter<const AlterationsT>(alterations: AlterationsT): WithAlterations<Of<{
        attributes: {
            maxTemperature: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureNumber: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minTemperature: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureNumber: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            selectedTemperatureLevel: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureLevel: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            step: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureStep: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportedTemperatureLevels: Attribute<string[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureLevel: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            temperatureSetpoint: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureNumber: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            setTemperature: Command<TypeFromFields<{
                targetTemperature: OptionalFieldType<number>;
                targetTemperatureLevel: OptionalFieldType<number>;
            }>, void, any>;
        };
        features: {
            temperatureLevel: BitFlag;
            temperatureNumber: BitFlag;
            temperatureStep: BitFlag;
        };
        id: 86;
        name: "TemperatureControl";
        revision: 1;
    }>, AlterationsT>;
    enable<const FlagsT>(flags: FlagsT): WithFlags<Of<{
        attributes: {
            maxTemperature: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureNumber: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minTemperature: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureNumber: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            selectedTemperatureLevel: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureLevel: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            step: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureStep: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportedTemperatureLevels: Attribute<string[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureLevel: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            temperatureSetpoint: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureNumber: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            setTemperature: Command<TypeFromFields<{
                targetTemperature: OptionalFieldType<number>;
                targetTemperatureLevel: OptionalFieldType<number>;
            }>, void, any>;
        };
        features: {
            temperatureLevel: BitFlag;
            temperatureNumber: BitFlag;
            temperatureStep: BitFlag;
        };
        id: 86;
        name: "TemperatureControl";
        revision: 1;
    }>, FlagsT>;
    set<const ValuesT>(values: ValuesT): WithValues<Of<{
        attributes: {
            maxTemperature: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureNumber: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minTemperature: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureNumber: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            selectedTemperatureLevel: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureLevel: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            step: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureStep: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportedTemperatureLevels: Attribute<string[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureLevel: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            temperatureSetpoint: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureNumber: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            setTemperature: Command<TypeFromFields<{
                targetTemperature: OptionalFieldType<number>;
                targetTemperatureLevel: OptionalFieldType<number>;
            }>, void, any>;
        };
        features: {
            temperatureLevel: BitFlag;
            temperatureNumber: BitFlag;
            temperatureStep: BitFlag;
        };
        id: 86;
        name: "TemperatureControl";
        revision: 1;
    }>, ValuesT>;
    with<const SelectionT>(...selection: SelectionT): Of<Of<{
        attributes: {
            maxTemperature: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureNumber: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minTemperature: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureNumber: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            selectedTemperatureLevel: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureLevel: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            step: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureStep: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportedTemperatureLevels: Attribute<string[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureLevel: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            temperatureSetpoint: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureNumber: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            setTemperature: Command<TypeFromFields<{
                targetTemperature: OptionalFieldType<number>;
                targetTemperatureLevel: OptionalFieldType<number>;
            }>, void, any>;
        };
        features: {
            temperatureLevel: BitFlag;
            temperatureNumber: BitFlag;
            temperatureStep: BitFlag;
        };
        id: 86;
        name: "TemperatureControl";
        revision: 1;
    }>, SelectionT>;
}

Hierarchy (view full)

Properties

attributes base commands events extensions features id name revision supportedFeatures unknown

Methods

alter enable set with

Properties

attributes

attributes: Merge<{
    maxTemperature: FixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            temperatureNumber: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    minTemperature: FixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            temperatureNumber: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    selectedTemperatureLevel: Attribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            temperatureLevel: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    step: FixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            temperatureStep: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    supportedTemperatureLevels: Attribute<string[], any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            temperatureLevel: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    temperatureSetpoint: Attribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            temperatureNumber: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
}, GlobalAttributes<{
    temperatureLevel: BitFlag;
    temperatureNumber: BitFlag;
    temperatureStep: BitFlag;
}>>

base

base: undefined

commands

commands: {
    setTemperature: Command<TypeFromFields<{
        targetTemperature: OptionalFieldType<number>;
        targetTemperatureLevel: OptionalFieldType<number>;
    }>, void, any>;
}

Type declaration

events

events: {}

extensions

extensions: undefined

features

features: {
    temperatureLevel: BitFlag;
    temperatureNumber: BitFlag;
    temperatureStep: BitFlag;
}

Type declaration

  • ReadonlytemperatureLevel: BitFlag

    TemperatureLevel

    For devices that use vendor-specific temperature levels for the temperature setpoint, such as some washers, the feature TL shall be used.

    See

    MatterSpecification.v13.Cluster § 8.2.4.2

  • ReadonlytemperatureNumber: BitFlag

    TemperatureNumber

    For devices that use an actual temperature value for the temperature setpoint, such as some water heaters, the feature TN shall be used. Note that this cluster provides and supports temperatures in degrees Celsius via the temperature data type.

    See

    MatterSpecification.v13.Cluster § 8.2.4.1

  • ReadonlytemperatureStep: BitFlag

    TemperatureStep

    For devices that support discrete temperature setpoints that are larger than the temperature resolution imposed via the temperature data type, the Step feature may be used.

    See

    MatterSpecification.v13.Cluster § 8.2.4.3

id

id: Branded<86, "ClusterId">

name

name

revision

revision

supportedFeatures

supportedFeatures: {}

unknown

unknown

Methods

alter

  • alter<const AlterationsT>(alterations): WithAlterations<Of<{
        attributes: {
            maxTemperature: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureNumber: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minTemperature: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureNumber: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            selectedTemperatureLevel: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureLevel: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            step: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureStep: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportedTemperatureLevels: Attribute<string[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureLevel: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            temperatureSetpoint: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureNumber: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            setTemperature: Command<TypeFromFields<{
                targetTemperature: OptionalFieldType<number>;
                targetTemperatureLevel: OptionalFieldType<number>;
            }>, void, any>;
        };
        features: {
            temperatureLevel: BitFlag;
            temperatureNumber: BitFlag;
            temperatureStep: BitFlag;
        };
        id: 86;
        name: "TemperatureControl";
        revision: 1;
    }>, AlterationsT>

  • Modify elements using ElementModifier.alter.

    Type Parameters

    • const AlterationsT extends Alterations<Of<{
          attributes: {
              maxTemperature: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      temperatureNumber: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              minTemperature: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      temperatureNumber: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              selectedTemperatureLevel: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      temperatureLevel: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              step: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      temperatureStep: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              supportedTemperatureLevels: Attribute<string[], any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      temperatureLevel: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              temperatureSetpoint: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      temperatureNumber: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          commands: {
              setTemperature: Command<TypeFromFields<{
                  targetTemperature: OptionalFieldType<number>;
                  targetTemperatureLevel: OptionalFieldType<number>;
              }>, void, any>;
          };
          features: {
              temperatureLevel: BitFlag;
              temperatureNumber: BitFlag;
              temperatureStep: BitFlag;
          };
          id: 86;
          name: "TemperatureControl";
          revision: 1;
      }>>

    Parameters

    Returns WithAlterations<Of<{
        attributes: {
            maxTemperature: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureNumber: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minTemperature: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureNumber: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            selectedTemperatureLevel: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureLevel: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            step: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureStep: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportedTemperatureLevels: Attribute<string[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureLevel: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            temperatureSetpoint: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureNumber: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            setTemperature: Command<TypeFromFields<{
                targetTemperature: OptionalFieldType<number>;
                targetTemperatureLevel: OptionalFieldType<number>;
            }>, void, any>;
        };
        features: {
            temperatureLevel: BitFlag;
            temperatureNumber: BitFlag;
            temperatureStep: BitFlag;
        };
        id: 86;
        name: "TemperatureControl";
        revision: 1;
    }>, AlterationsT>

enable

  • enable<const FlagsT>(flags): WithFlags<Of<{
        attributes: {
            maxTemperature: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureNumber: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minTemperature: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureNumber: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            selectedTemperatureLevel: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureLevel: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            step: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureStep: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportedTemperatureLevels: Attribute<string[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureLevel: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            temperatureSetpoint: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureNumber: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            setTemperature: Command<TypeFromFields<{
                targetTemperature: OptionalFieldType<number>;
                targetTemperatureLevel: OptionalFieldType<number>;
            }>, void, any>;
        };
        features: {
            temperatureLevel: BitFlag;
            temperatureNumber: BitFlag;
            temperatureStep: BitFlag;
        };
        id: 86;
        name: "TemperatureControl";
        revision: 1;
    }>, FlagsT>

  • Modify elements using ElementModifier.enable.

    Type Parameters

    • const FlagsT extends ElementFlags<Of<{
          attributes: {
              maxTemperature: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      temperatureNumber: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              minTemperature: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      temperatureNumber: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              selectedTemperatureLevel: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      temperatureLevel: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              step: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      temperatureStep: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              supportedTemperatureLevels: Attribute<string[], any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      temperatureLevel: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              temperatureSetpoint: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      temperatureNumber: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          commands: {
              setTemperature: Command<TypeFromFields<{
                  targetTemperature: OptionalFieldType<number>;
                  targetTemperatureLevel: OptionalFieldType<number>;
              }>, void, any>;
          };
          features: {
              temperatureLevel: BitFlag;
              temperatureNumber: BitFlag;
              temperatureStep: BitFlag;
          };
          id: 86;
          name: "TemperatureControl";
          revision: 1;
      }>>

    Parameters

    Returns WithFlags<Of<{
        attributes: {
            maxTemperature: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureNumber: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minTemperature: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureNumber: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            selectedTemperatureLevel: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureLevel: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            step: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureStep: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportedTemperatureLevels: Attribute<string[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureLevel: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            temperatureSetpoint: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureNumber: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            setTemperature: Command<TypeFromFields<{
                targetTemperature: OptionalFieldType<number>;
                targetTemperatureLevel: OptionalFieldType<number>;
            }>, void, any>;
        };
        features: {
            temperatureLevel: BitFlag;
            temperatureNumber: BitFlag;
            temperatureStep: BitFlag;
        };
        id: 86;
        name: "TemperatureControl";
        revision: 1;
    }>, FlagsT>

set

  • set<const ValuesT>(values): WithValues<Of<{
        attributes: {
            maxTemperature: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureNumber: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minTemperature: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureNumber: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            selectedTemperatureLevel: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureLevel: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            step: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureStep: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportedTemperatureLevels: Attribute<string[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureLevel: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            temperatureSetpoint: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureNumber: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            setTemperature: Command<TypeFromFields<{
                targetTemperature: OptionalFieldType<number>;
                targetTemperatureLevel: OptionalFieldType<number>;
            }>, void, any>;
        };
        features: {
            temperatureLevel: BitFlag;
            temperatureNumber: BitFlag;
            temperatureStep: BitFlag;
        };
        id: 86;
        name: "TemperatureControl";
        revision: 1;
    }>, ValuesT>

  • Modify elements using ElementModifier.set.

    Type Parameters

    • const ValuesT extends {
          maxTemperature?: number;
          minTemperature?: number;
          selectedTemperatureLevel?: number;
          step?: number;
          supportedTemperatureLevels?: string[];
          temperatureSetpoint?: number;
      }

    Parameters

    Returns WithValues<Of<{
        attributes: {
            maxTemperature: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureNumber: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minTemperature: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureNumber: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            selectedTemperatureLevel: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureLevel: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            step: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureStep: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportedTemperatureLevels: Attribute<string[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureLevel: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            temperatureSetpoint: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureNumber: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            setTemperature: Command<TypeFromFields<{
                targetTemperature: OptionalFieldType<number>;
                targetTemperatureLevel: OptionalFieldType<number>;
            }>, void, any>;
        };
        features: {
            temperatureLevel: BitFlag;
            temperatureNumber: BitFlag;
            temperatureStep: BitFlag;
        };
        id: 86;
        name: "TemperatureControl";
        revision: 1;
    }>, ValuesT>

with

  • with<const SelectionT>(...selection): Of<Of<{
        attributes: {
            maxTemperature: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureNumber: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minTemperature: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureNumber: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            selectedTemperatureLevel: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureLevel: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            step: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureStep: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportedTemperatureLevels: Attribute<string[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureLevel: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            temperatureSetpoint: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureNumber: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            setTemperature: Command<TypeFromFields<{
                targetTemperature: OptionalFieldType<number>;
                targetTemperatureLevel: OptionalFieldType<number>;
            }>, void, any>;
        };
        features: {
            temperatureLevel: BitFlag;
            temperatureNumber: BitFlag;
            temperatureStep: BitFlag;
        };
        id: 86;
        name: "TemperatureControl";
        revision: 1;
    }>, SelectionT>

  • Select features using ClusterComposer.compose.

    Type Parameters

    • const SelectionT extends FeatureSelection<Of<{
          attributes: {
              maxTemperature: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      temperatureNumber: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              minTemperature: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      temperatureNumber: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              selectedTemperatureLevel: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      temperatureLevel: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              step: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      temperatureStep: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              supportedTemperatureLevels: Attribute<string[], any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      temperatureLevel: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              temperatureSetpoint: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      temperatureNumber: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          commands: {
              setTemperature: Command<TypeFromFields<{
                  targetTemperature: OptionalFieldType<number>;
                  targetTemperatureLevel: OptionalFieldType<number>;
              }>, void, any>;
          };
          features: {
              temperatureLevel: BitFlag;
              temperatureNumber: BitFlag;
              temperatureStep: BitFlag;
          };
          id: 86;
          name: "TemperatureControl";
          revision: 1;
      }>>

    Parameters

    Returns Of<Of<{
        attributes: {
            maxTemperature: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureNumber: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minTemperature: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureNumber: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            selectedTemperatureLevel: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureLevel: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            step: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureStep: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportedTemperatureLevels: Attribute<string[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureLevel: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            temperatureSetpoint: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    temperatureNumber: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            setTemperature: Command<TypeFromFields<{
                targetTemperature: OptionalFieldType<number>;
                targetTemperatureLevel: OptionalFieldType<number>;
            }>, void, any>;
        };
        features: {
            temperatureLevel: BitFlag;
            temperatureNumber: BitFlag;
            temperatureStep: BitFlag;
        };
        id: 86;
        name: "TemperatureControl";
        revision: 1;
    }>, SelectionT>

Settings

Member Visibility

On This Page

Properties
Methods