Interface Cluster

This cluster specifies an interface to control the speed of a fan.

FanControlCluster supports optional features that you can enable with the FanControlCluster.with() factory method.

See

MatterSpecification.v13.Cluster § 4.4

interface Cluster {
    attributes: Merge<{
        fanMode: WritableAttribute<FanControl.FanMode, any>;
        fanModeSequence: FixedAttribute<FanControl.FanModeSequence, any>;
        percentCurrent: Attribute<number, any>;
        percentSetting: WritableAttribute<null | number, any>;
    }, GlobalAttributes<{
        airflowDirection: BitFlag;
        auto: BitFlag;
        multiSpeed: BitFlag;
        rocking: BitFlag;
        step: BitFlag;
        wind: BitFlag;
    }>>;
    base: undefined;
    commands: {};
    events: {};
    extensions: readonly [{
        component: {
            attributes: {
                speedCurrent: Attribute<number, any>;
                speedMax: FixedAttribute<number, any>;
                speedSetting: WritableAttribute<null | number, any>;
            };
        };
        flags: {
            multiSpeed: true;
        };
    }, {
        component: {
            attributes: {
                rockSetting: WritableAttribute<TypeFromPartialBitSchema<{
                    rockLeftRight: BitFlag;
                    rockRound: BitFlag;
                    rockUpDown: BitFlag;
                }>, any>;
                rockSupport: FixedAttribute<TypeFromPartialBitSchema<{
                    rockLeftRight: BitFlag;
                    rockRound: BitFlag;
                    rockUpDown: BitFlag;
                }>, any>;
            };
        };
        flags: {
            rocking: true;
        };
    }, {
        component: {
            attributes: {
                windSetting: WritableAttribute<TypeFromPartialBitSchema<{
                    naturalWind: BitFlag;
                    sleepWind: BitFlag;
                }>, any>;
                windSupport: FixedAttribute<TypeFromPartialBitSchema<{
                    naturalWind: BitFlag;
                    sleepWind: BitFlag;
                }>, any>;
            };
        };
        flags: {
            wind: true;
        };
    }, {
        component: {
            attributes: {
                airflowDirection: WritableAttribute<FanControl.AirflowDirection, any>;
            };
        };
        flags: {
            airflowDirection: true;
        };
    }, {
        component: {
            commands: {
                step: Command<TypeFromFields<{
                    direction: FieldType<FanControl.StepDirection>;
                    lowestOff: OptionalFieldType<boolean>;
                    wrap: OptionalFieldType<boolean>;
                }>, void, any>;
            };
        };
        flags: {
            step: true;
        };
    }];
    features: {
        airflowDirection: BitFlag;
        auto: BitFlag;
        multiSpeed: BitFlag;
        rocking: BitFlag;
        step: BitFlag;
        wind: BitFlag;
    };
    id: Branded<514, "ClusterId">;
    name: "FanControl";
    revision: 4;
    supportedFeatures: {};
    unknown: false;
    alter<const AlterationsT>(alterations: AlterationsT): WithAlterations<Of<{
        attributes: {
            fanMode: WritableAttribute<FanControl.FanMode, any>;
            fanModeSequence: FixedAttribute<FanControl.FanModeSequence, any>;
            percentCurrent: Attribute<number, any>;
            percentSetting: WritableAttribute<null | number, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    speedCurrent: Attribute<number, any>;
                    speedMax: FixedAttribute<number, any>;
                    speedSetting: WritableAttribute<null | number, any>;
                };
            };
            flags: {
                multiSpeed: true;
            };
        }, {
            component: {
                attributes: {
                    rockSetting: WritableAttribute<TypeFromPartialBitSchema<{
                        rockLeftRight: BitFlag;
                        rockRound: BitFlag;
                        rockUpDown: BitFlag;
                    }>, any>;
                    rockSupport: FixedAttribute<TypeFromPartialBitSchema<{
                        rockLeftRight: BitFlag;
                        rockRound: BitFlag;
                        rockUpDown: BitFlag;
                    }>, any>;
                };
            };
            flags: {
                rocking: true;
            };
        }, {
            component: {
                attributes: {
                    windSetting: WritableAttribute<TypeFromPartialBitSchema<{
                        naturalWind: BitFlag;
                        sleepWind: BitFlag;
                    }>, any>;
                    windSupport: FixedAttribute<TypeFromPartialBitSchema<{
                        naturalWind: BitFlag;
                        sleepWind: BitFlag;
                    }>, any>;
                };
            };
            flags: {
                wind: true;
            };
        }, {
            component: {
                attributes: {
                    airflowDirection: WritableAttribute<FanControl.AirflowDirection, any>;
                };
            };
            flags: {
                airflowDirection: true;
            };
        }, {
            component: {
                commands: {
                    step: Command<TypeFromFields<{
                        direction: FieldType<(...)>;
                        lowestOff: OptionalFieldType<(...)>;
                        wrap: OptionalFieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                step: true;
            };
        }];
        features: {
            airflowDirection: BitFlag;
            auto: BitFlag;
            multiSpeed: BitFlag;
            rocking: BitFlag;
            step: BitFlag;
            wind: BitFlag;
        };
        id: 514;
        name: "FanControl";
        revision: 4;
    }>, AlterationsT>;
    enable<const FlagsT>(flags: FlagsT): WithFlags<Of<{
        attributes: {
            fanMode: WritableAttribute<FanControl.FanMode, any>;
            fanModeSequence: FixedAttribute<FanControl.FanModeSequence, any>;
            percentCurrent: Attribute<number, any>;
            percentSetting: WritableAttribute<null | number, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    speedCurrent: Attribute<number, any>;
                    speedMax: FixedAttribute<number, any>;
                    speedSetting: WritableAttribute<null | number, any>;
                };
            };
            flags: {
                multiSpeed: true;
            };
        }, {
            component: {
                attributes: {
                    rockSetting: WritableAttribute<TypeFromPartialBitSchema<{
                        rockLeftRight: BitFlag;
                        rockRound: BitFlag;
                        rockUpDown: BitFlag;
                    }>, any>;
                    rockSupport: FixedAttribute<TypeFromPartialBitSchema<{
                        rockLeftRight: BitFlag;
                        rockRound: BitFlag;
                        rockUpDown: BitFlag;
                    }>, any>;
                };
            };
            flags: {
                rocking: true;
            };
        }, {
            component: {
                attributes: {
                    windSetting: WritableAttribute<TypeFromPartialBitSchema<{
                        naturalWind: BitFlag;
                        sleepWind: BitFlag;
                    }>, any>;
                    windSupport: FixedAttribute<TypeFromPartialBitSchema<{
                        naturalWind: BitFlag;
                        sleepWind: BitFlag;
                    }>, any>;
                };
            };
            flags: {
                wind: true;
            };
        }, {
            component: {
                attributes: {
                    airflowDirection: WritableAttribute<FanControl.AirflowDirection, any>;
                };
            };
            flags: {
                airflowDirection: true;
            };
        }, {
            component: {
                commands: {
                    step: Command<TypeFromFields<{
                        direction: FieldType<(...)>;
                        lowestOff: OptionalFieldType<(...)>;
                        wrap: OptionalFieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                step: true;
            };
        }];
        features: {
            airflowDirection: BitFlag;
            auto: BitFlag;
            multiSpeed: BitFlag;
            rocking: BitFlag;
            step: BitFlag;
            wind: BitFlag;
        };
        id: 514;
        name: "FanControl";
        revision: 4;
    }>, FlagsT>;
    set<const ValuesT>(values: ValuesT): WithValues<Of<{
        attributes: {
            fanMode: WritableAttribute<FanControl.FanMode, any>;
            fanModeSequence: FixedAttribute<FanControl.FanModeSequence, any>;
            percentCurrent: Attribute<number, any>;
            percentSetting: WritableAttribute<null | number, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    speedCurrent: Attribute<number, any>;
                    speedMax: FixedAttribute<number, any>;
                    speedSetting: WritableAttribute<null | number, any>;
                };
            };
            flags: {
                multiSpeed: true;
            };
        }, {
            component: {
                attributes: {
                    rockSetting: WritableAttribute<TypeFromPartialBitSchema<{
                        rockLeftRight: BitFlag;
                        rockRound: BitFlag;
                        rockUpDown: BitFlag;
                    }>, any>;
                    rockSupport: FixedAttribute<TypeFromPartialBitSchema<{
                        rockLeftRight: BitFlag;
                        rockRound: BitFlag;
                        rockUpDown: BitFlag;
                    }>, any>;
                };
            };
            flags: {
                rocking: true;
            };
        }, {
            component: {
                attributes: {
                    windSetting: WritableAttribute<TypeFromPartialBitSchema<{
                        naturalWind: BitFlag;
                        sleepWind: BitFlag;
                    }>, any>;
                    windSupport: FixedAttribute<TypeFromPartialBitSchema<{
                        naturalWind: BitFlag;
                        sleepWind: BitFlag;
                    }>, any>;
                };
            };
            flags: {
                wind: true;
            };
        }, {
            component: {
                attributes: {
                    airflowDirection: WritableAttribute<FanControl.AirflowDirection, any>;
                };
            };
            flags: {
                airflowDirection: true;
            };
        }, {
            component: {
                commands: {
                    step: Command<TypeFromFields<{
                        direction: FieldType<(...)>;
                        lowestOff: OptionalFieldType<(...)>;
                        wrap: OptionalFieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                step: true;
            };
        }];
        features: {
            airflowDirection: BitFlag;
            auto: BitFlag;
            multiSpeed: BitFlag;
            rocking: BitFlag;
            step: BitFlag;
            wind: BitFlag;
        };
        id: 514;
        name: "FanControl";
        revision: 4;
    }>, ValuesT>;
    with<const SelectionT>(...selection: SelectionT): Of<Of<{
        attributes: {
            fanMode: WritableAttribute<FanControl.FanMode, any>;
            fanModeSequence: FixedAttribute<FanControl.FanModeSequence, any>;
            percentCurrent: Attribute<number, any>;
            percentSetting: WritableAttribute<null | number, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    speedCurrent: Attribute<number, any>;
                    speedMax: FixedAttribute<number, any>;
                    speedSetting: WritableAttribute<null | number, any>;
                };
            };
            flags: {
                multiSpeed: true;
            };
        }, {
            component: {
                attributes: {
                    rockSetting: WritableAttribute<TypeFromPartialBitSchema<{
                        rockLeftRight: BitFlag;
                        rockRound: BitFlag;
                        rockUpDown: BitFlag;
                    }>, any>;
                    rockSupport: FixedAttribute<TypeFromPartialBitSchema<{
                        rockLeftRight: BitFlag;
                        rockRound: BitFlag;
                        rockUpDown: BitFlag;
                    }>, any>;
                };
            };
            flags: {
                rocking: true;
            };
        }, {
            component: {
                attributes: {
                    windSetting: WritableAttribute<TypeFromPartialBitSchema<{
                        naturalWind: BitFlag;
                        sleepWind: BitFlag;
                    }>, any>;
                    windSupport: FixedAttribute<TypeFromPartialBitSchema<{
                        naturalWind: BitFlag;
                        sleepWind: BitFlag;
                    }>, any>;
                };
            };
            flags: {
                wind: true;
            };
        }, {
            component: {
                attributes: {
                    airflowDirection: WritableAttribute<FanControl.AirflowDirection, any>;
                };
            };
            flags: {
                airflowDirection: true;
            };
        }, {
            component: {
                commands: {
                    step: Command<TypeFromFields<{
                        direction: FieldType<(...)>;
                        lowestOff: OptionalFieldType<(...)>;
                        wrap: OptionalFieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                step: true;
            };
        }];
        features: {
            airflowDirection: BitFlag;
            auto: BitFlag;
            multiSpeed: BitFlag;
            rocking: BitFlag;
            step: BitFlag;
            wind: BitFlag;
        };
        id: 514;
        name: "FanControl";
        revision: 4;
    }>, 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<{
    fanMode: WritableAttribute<FanControl.FanMode, any>;
    fanModeSequence: FixedAttribute<FanControl.FanModeSequence, any>;
    percentCurrent: Attribute<number, any>;
    percentSetting: WritableAttribute<null | number, any>;
}, GlobalAttributes<{
    airflowDirection: BitFlag;
    auto: BitFlag;
    multiSpeed: BitFlag;
    rocking: BitFlag;
    step: BitFlag;
    wind: BitFlag;
}>>

Type declaration

  • ReadonlyfanMode: WritableAttribute<FanControl.FanMode, any>

    Indicates the current speed mode of the fan. This attribute may be written by the client to request a different fan mode. A server shall return INVALID_IN_STATE to indicate that the fan is not in a state where the FanMode can be changed to the requested value. A server may have FanMode values that it can never be set to. For example, where this cluster appears on the same or another endpoint as other clusters with a system dependency, for example the Thermostat cluster, attempting to set the FanMode attribute of this cluster to Off may not be allowed by the system.

    This attribute shall be set to one of the values in FanModeEnum.

    When the FanMode attribute is successfully written to, the PercentSetting and SpeedSetting (if present) attributes shall be set to appropriate values, as defined by the Percent Rules and Speed Rules respectively, unless otherwise specified below.

    When the FanMode attribute is set to any given mode, the PercentCurrent and SpeedCurrent (if present) shall indicate the actual currently operating fan speed, unless otherwise specified below.

    See

    MatterSpecification.v13.Cluster § 4.4.6.1

  • ReadonlyfanModeSequence: FixedAttribute<FanControl.FanModeSequence, any>

    This attribute indicates the fan speed ranges that shall be supported.

    See

    MatterSpecification.v13.Cluster § 4.4.6.2

  • ReadonlypercentCurrent: Attribute<number, any>

    Indicates the actual currently operating fan speed, or zero to indicate that the fan is off. There may be a temporary mismatch between the value of this attribute and the value of the PercentSetting attribute due to other system requirements that would not allow the fan to operate at the requested setting. See Percent Rules for more details.

    See

    MatterSpecification.v13.Cluster § 4.4.6.4

  • ReadonlypercentSetting: WritableAttribute<null | number, any>

    Indicates the speed setting for the fan. This attribute may be written by the client to indicate a new fan speed. If the client writes null to this attribute, the attribute value shall NOT change. A server shall return INVALID_IN_STATE to indicate that the fan is not in a state where the PercentSetting can be changed to the requested value.

    If this is successfully written to 0, the server shall set the FanMode attribute value to Off.

    See

    MatterSpecification.v13.Cluster § 4.4.6.3

base

base: undefined

commands

commands: {}

events

events: {}

extensions

extensions: readonly [{
    component: {
        attributes: {
            speedCurrent: Attribute<number, any>;
            speedMax: FixedAttribute<number, any>;
            speedSetting: WritableAttribute<null | number, any>;
        };
    };
    flags: {
        multiSpeed: true;
    };
}, {
    component: {
        attributes: {
            rockSetting: WritableAttribute<TypeFromPartialBitSchema<{
                rockLeftRight: BitFlag;
                rockRound: BitFlag;
                rockUpDown: BitFlag;
            }>, any>;
            rockSupport: FixedAttribute<TypeFromPartialBitSchema<{
                rockLeftRight: BitFlag;
                rockRound: BitFlag;
                rockUpDown: BitFlag;
            }>, any>;
        };
    };
    flags: {
        rocking: true;
    };
}, {
    component: {
        attributes: {
            windSetting: WritableAttribute<TypeFromPartialBitSchema<{
                naturalWind: BitFlag;
                sleepWind: BitFlag;
            }>, any>;
            windSupport: FixedAttribute<TypeFromPartialBitSchema<{
                naturalWind: BitFlag;
                sleepWind: BitFlag;
            }>, any>;
        };
    };
    flags: {
        wind: true;
    };
}, {
    component: {
        attributes: {
            airflowDirection: WritableAttribute<FanControl.AirflowDirection, any>;
        };
    };
    flags: {
        airflowDirection: true;
    };
}, {
    component: {
        commands: {
            step: Command<TypeFromFields<{
                direction: FieldType<FanControl.StepDirection>;
                lowestOff: OptionalFieldType<boolean>;
                wrap: OptionalFieldType<boolean>;
            }>, void, any>;
        };
    };
    flags: {
        step: true;
    };
}]

features

features: {
    airflowDirection: BitFlag;
    auto: BitFlag;
    multiSpeed: BitFlag;
    rocking: BitFlag;
    step: BitFlag;
    wind: BitFlag;
}

Type declaration

  • ReadonlyairflowDirection: BitFlag

    AirflowDirection

    Airflow Direction attribute is supported

  • Readonlyauto: BitFlag

    Auto

    Automatic mode supported for fan speed

  • ReadonlymultiSpeed: BitFlag

    MultiSpeed

    Legacy Fan Control cluster revision 0-1 defined 3 speeds (low, medium and high) plus automatic speed control but left it up to the implementer to decide what was supported. Therefore, it is assumed that legacy client implementations are capable of determining, from the server, the number of speeds supported between 1, 2, or 3, and whether automatic speed control is supported.

    The MultiSpeed feature includes new attributes that support a running fan speed value from 0 to SpeedMax, which has a maximum of 100.

    See Speed Rules for more details.

    See

    MatterSpecification.v13.Cluster § 4.4.4.1

  • Readonlyrocking: BitFlag

    Rocking

    Rocking movement supported

  • Readonlystep: BitFlag

    Step

    Step command supported

  • Readonlywind: BitFlag

    Wind

    Wind emulation supported

id

id: Branded<514, "ClusterId">

name

name

revision

revision

supportedFeatures

supportedFeatures: {}

unknown

unknown

Methods

alter

  • alter<const AlterationsT>(alterations): WithAlterations<Of<{
        attributes: {
            fanMode: WritableAttribute<FanControl.FanMode, any>;
            fanModeSequence: FixedAttribute<FanControl.FanModeSequence, any>;
            percentCurrent: Attribute<number, any>;
            percentSetting: WritableAttribute<null | number, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    speedCurrent: Attribute<number, any>;
                    speedMax: FixedAttribute<number, any>;
                    speedSetting: WritableAttribute<null | number, any>;
                };
            };
            flags: {
                multiSpeed: true;
            };
        }, {
            component: {
                attributes: {
                    rockSetting: WritableAttribute<TypeFromPartialBitSchema<{
                        rockLeftRight: BitFlag;
                        rockRound: BitFlag;
                        rockUpDown: BitFlag;
                    }>, any>;
                    rockSupport: FixedAttribute<TypeFromPartialBitSchema<{
                        rockLeftRight: BitFlag;
                        rockRound: BitFlag;
                        rockUpDown: BitFlag;
                    }>, any>;
                };
            };
            flags: {
                rocking: true;
            };
        }, {
            component: {
                attributes: {
                    windSetting: WritableAttribute<TypeFromPartialBitSchema<{
                        naturalWind: BitFlag;
                        sleepWind: BitFlag;
                    }>, any>;
                    windSupport: FixedAttribute<TypeFromPartialBitSchema<{
                        naturalWind: BitFlag;
                        sleepWind: BitFlag;
                    }>, any>;
                };
            };
            flags: {
                wind: true;
            };
        }, {
            component: {
                attributes: {
                    airflowDirection: WritableAttribute<FanControl.AirflowDirection, any>;
                };
            };
            flags: {
                airflowDirection: true;
            };
        }, {
            component: {
                commands: {
                    step: Command<TypeFromFields<{
                        direction: FieldType<(...)>;
                        lowestOff: OptionalFieldType<(...)>;
                        wrap: OptionalFieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                step: true;
            };
        }];
        features: {
            airflowDirection: BitFlag;
            auto: BitFlag;
            multiSpeed: BitFlag;
            rocking: BitFlag;
            step: BitFlag;
            wind: BitFlag;
        };
        id: 514;
        name: "FanControl";
        revision: 4;
    }>, AlterationsT>

  • Modify elements using ElementModifier.alter.

    Type Parameters

    • const AlterationsT extends Alterations<Of<{
          attributes: {
              fanMode: WritableAttribute<FanControl.FanMode, any>;
              fanModeSequence: FixedAttribute<FanControl.FanModeSequence, any>;
              percentCurrent: Attribute<number, any>;
              percentSetting: WritableAttribute<null | number, any>;
          };
          extensions: readonly [{
              component: {
                  attributes: {
                      speedCurrent: Attribute<number, any>;
                      speedMax: FixedAttribute<number, any>;
                      speedSetting: WritableAttribute<null | number, any>;
                  };
              };
              flags: {
                  multiSpeed: true;
              };
          }, {
              component: {
                  attributes: {
                      rockSetting: WritableAttribute<TypeFromPartialBitSchema<{
                          rockLeftRight: BitFlag;
                          rockRound: BitFlag;
                          rockUpDown: BitFlag;
                      }>, any>;
                      rockSupport: FixedAttribute<TypeFromPartialBitSchema<{
                          rockLeftRight: BitFlag;
                          rockRound: BitFlag;
                          rockUpDown: BitFlag;
                      }>, any>;
                  };
              };
              flags: {
                  rocking: true;
              };
          }, {
              component: {
                  attributes: {
                      windSetting: WritableAttribute<TypeFromPartialBitSchema<{
                          naturalWind: BitFlag;
                          sleepWind: BitFlag;
                      }>, any>;
                      windSupport: FixedAttribute<TypeFromPartialBitSchema<{
                          naturalWind: BitFlag;
                          sleepWind: BitFlag;
                      }>, any>;
                  };
              };
              flags: {
                  wind: true;
              };
          }, {
              component: {
                  attributes: {
                      airflowDirection: WritableAttribute<FanControl.AirflowDirection, any>;
                  };
              };
              flags: {
                  airflowDirection: true;
              };
          }, {
              component: {
                  commands: {
                      step: Command<TypeFromFields<{
                          direction: FieldType<(...)>;
                          lowestOff: OptionalFieldType<(...)>;
                          wrap: OptionalFieldType<(...)>;
                      }>, void, any>;
                  };
              };
              flags: {
                  step: true;
              };
          }];
          features: {
              airflowDirection: BitFlag;
              auto: BitFlag;
              multiSpeed: BitFlag;
              rocking: BitFlag;
              step: BitFlag;
              wind: BitFlag;
          };
          id: 514;
          name: "FanControl";
          revision: 4;
      }>>

    Parameters

    Returns WithAlterations<Of<{
        attributes: {
            fanMode: WritableAttribute<FanControl.FanMode, any>;
            fanModeSequence: FixedAttribute<FanControl.FanModeSequence, any>;
            percentCurrent: Attribute<number, any>;
            percentSetting: WritableAttribute<null | number, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    speedCurrent: Attribute<number, any>;
                    speedMax: FixedAttribute<number, any>;
                    speedSetting: WritableAttribute<null | number, any>;
                };
            };
            flags: {
                multiSpeed: true;
            };
        }, {
            component: {
                attributes: {
                    rockSetting: WritableAttribute<TypeFromPartialBitSchema<{
                        rockLeftRight: BitFlag;
                        rockRound: BitFlag;
                        rockUpDown: BitFlag;
                    }>, any>;
                    rockSupport: FixedAttribute<TypeFromPartialBitSchema<{
                        rockLeftRight: BitFlag;
                        rockRound: BitFlag;
                        rockUpDown: BitFlag;
                    }>, any>;
                };
            };
            flags: {
                rocking: true;
            };
        }, {
            component: {
                attributes: {
                    windSetting: WritableAttribute<TypeFromPartialBitSchema<{
                        naturalWind: BitFlag;
                        sleepWind: BitFlag;
                    }>, any>;
                    windSupport: FixedAttribute<TypeFromPartialBitSchema<{
                        naturalWind: BitFlag;
                        sleepWind: BitFlag;
                    }>, any>;
                };
            };
            flags: {
                wind: true;
            };
        }, {
            component: {
                attributes: {
                    airflowDirection: WritableAttribute<FanControl.AirflowDirection, any>;
                };
            };
            flags: {
                airflowDirection: true;
            };
        }, {
            component: {
                commands: {
                    step: Command<TypeFromFields<{
                        direction: FieldType<(...)>;
                        lowestOff: OptionalFieldType<(...)>;
                        wrap: OptionalFieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                step: true;
            };
        }];
        features: {
            airflowDirection: BitFlag;
            auto: BitFlag;
            multiSpeed: BitFlag;
            rocking: BitFlag;
            step: BitFlag;
            wind: BitFlag;
        };
        id: 514;
        name: "FanControl";
        revision: 4;
    }>, AlterationsT>

enable

  • enable<const FlagsT>(flags): WithFlags<Of<{
        attributes: {
            fanMode: WritableAttribute<FanControl.FanMode, any>;
            fanModeSequence: FixedAttribute<FanControl.FanModeSequence, any>;
            percentCurrent: Attribute<number, any>;
            percentSetting: WritableAttribute<null | number, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    speedCurrent: Attribute<number, any>;
                    speedMax: FixedAttribute<number, any>;
                    speedSetting: WritableAttribute<null | number, any>;
                };
            };
            flags: {
                multiSpeed: true;
            };
        }, {
            component: {
                attributes: {
                    rockSetting: WritableAttribute<TypeFromPartialBitSchema<{
                        rockLeftRight: BitFlag;
                        rockRound: BitFlag;
                        rockUpDown: BitFlag;
                    }>, any>;
                    rockSupport: FixedAttribute<TypeFromPartialBitSchema<{
                        rockLeftRight: BitFlag;
                        rockRound: BitFlag;
                        rockUpDown: BitFlag;
                    }>, any>;
                };
            };
            flags: {
                rocking: true;
            };
        }, {
            component: {
                attributes: {
                    windSetting: WritableAttribute<TypeFromPartialBitSchema<{
                        naturalWind: BitFlag;
                        sleepWind: BitFlag;
                    }>, any>;
                    windSupport: FixedAttribute<TypeFromPartialBitSchema<{
                        naturalWind: BitFlag;
                        sleepWind: BitFlag;
                    }>, any>;
                };
            };
            flags: {
                wind: true;
            };
        }, {
            component: {
                attributes: {
                    airflowDirection: WritableAttribute<FanControl.AirflowDirection, any>;
                };
            };
            flags: {
                airflowDirection: true;
            };
        }, {
            component: {
                commands: {
                    step: Command<TypeFromFields<{
                        direction: FieldType<(...)>;
                        lowestOff: OptionalFieldType<(...)>;
                        wrap: OptionalFieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                step: true;
            };
        }];
        features: {
            airflowDirection: BitFlag;
            auto: BitFlag;
            multiSpeed: BitFlag;
            rocking: BitFlag;
            step: BitFlag;
            wind: BitFlag;
        };
        id: 514;
        name: "FanControl";
        revision: 4;
    }>, FlagsT>

  • Modify elements using ElementModifier.enable.

    Type Parameters

    • const FlagsT extends ElementFlags<Of<{
          attributes: {
              fanMode: WritableAttribute<FanControl.FanMode, any>;
              fanModeSequence: FixedAttribute<FanControl.FanModeSequence, any>;
              percentCurrent: Attribute<number, any>;
              percentSetting: WritableAttribute<null | number, any>;
          };
          extensions: readonly [{
              component: {
                  attributes: {
                      speedCurrent: Attribute<number, any>;
                      speedMax: FixedAttribute<number, any>;
                      speedSetting: WritableAttribute<null | number, any>;
                  };
              };
              flags: {
                  multiSpeed: true;
              };
          }, {
              component: {
                  attributes: {
                      rockSetting: WritableAttribute<TypeFromPartialBitSchema<{
                          rockLeftRight: BitFlag;
                          rockRound: BitFlag;
                          rockUpDown: BitFlag;
                      }>, any>;
                      rockSupport: FixedAttribute<TypeFromPartialBitSchema<{
                          rockLeftRight: BitFlag;
                          rockRound: BitFlag;
                          rockUpDown: BitFlag;
                      }>, any>;
                  };
              };
              flags: {
                  rocking: true;
              };
          }, {
              component: {
                  attributes: {
                      windSetting: WritableAttribute<TypeFromPartialBitSchema<{
                          naturalWind: BitFlag;
                          sleepWind: BitFlag;
                      }>, any>;
                      windSupport: FixedAttribute<TypeFromPartialBitSchema<{
                          naturalWind: BitFlag;
                          sleepWind: BitFlag;
                      }>, any>;
                  };
              };
              flags: {
                  wind: true;
              };
          }, {
              component: {
                  attributes: {
                      airflowDirection: WritableAttribute<FanControl.AirflowDirection, any>;
                  };
              };
              flags: {
                  airflowDirection: true;
              };
          }, {
              component: {
                  commands: {
                      step: Command<TypeFromFields<{
                          direction: FieldType<(...)>;
                          lowestOff: OptionalFieldType<(...)>;
                          wrap: OptionalFieldType<(...)>;
                      }>, void, any>;
                  };
              };
              flags: {
                  step: true;
              };
          }];
          features: {
              airflowDirection: BitFlag;
              auto: BitFlag;
              multiSpeed: BitFlag;
              rocking: BitFlag;
              step: BitFlag;
              wind: BitFlag;
          };
          id: 514;
          name: "FanControl";
          revision: 4;
      }>>

    Parameters

    Returns WithFlags<Of<{
        attributes: {
            fanMode: WritableAttribute<FanControl.FanMode, any>;
            fanModeSequence: FixedAttribute<FanControl.FanModeSequence, any>;
            percentCurrent: Attribute<number, any>;
            percentSetting: WritableAttribute<null | number, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    speedCurrent: Attribute<number, any>;
                    speedMax: FixedAttribute<number, any>;
                    speedSetting: WritableAttribute<null | number, any>;
                };
            };
            flags: {
                multiSpeed: true;
            };
        }, {
            component: {
                attributes: {
                    rockSetting: WritableAttribute<TypeFromPartialBitSchema<{
                        rockLeftRight: BitFlag;
                        rockRound: BitFlag;
                        rockUpDown: BitFlag;
                    }>, any>;
                    rockSupport: FixedAttribute<TypeFromPartialBitSchema<{
                        rockLeftRight: BitFlag;
                        rockRound: BitFlag;
                        rockUpDown: BitFlag;
                    }>, any>;
                };
            };
            flags: {
                rocking: true;
            };
        }, {
            component: {
                attributes: {
                    windSetting: WritableAttribute<TypeFromPartialBitSchema<{
                        naturalWind: BitFlag;
                        sleepWind: BitFlag;
                    }>, any>;
                    windSupport: FixedAttribute<TypeFromPartialBitSchema<{
                        naturalWind: BitFlag;
                        sleepWind: BitFlag;
                    }>, any>;
                };
            };
            flags: {
                wind: true;
            };
        }, {
            component: {
                attributes: {
                    airflowDirection: WritableAttribute<FanControl.AirflowDirection, any>;
                };
            };
            flags: {
                airflowDirection: true;
            };
        }, {
            component: {
                commands: {
                    step: Command<TypeFromFields<{
                        direction: FieldType<(...)>;
                        lowestOff: OptionalFieldType<(...)>;
                        wrap: OptionalFieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                step: true;
            };
        }];
        features: {
            airflowDirection: BitFlag;
            auto: BitFlag;
            multiSpeed: BitFlag;
            rocking: BitFlag;
            step: BitFlag;
            wind: BitFlag;
        };
        id: 514;
        name: "FanControl";
        revision: 4;
    }>, FlagsT>

set

  • set<const ValuesT>(values): WithValues<Of<{
        attributes: {
            fanMode: WritableAttribute<FanControl.FanMode, any>;
            fanModeSequence: FixedAttribute<FanControl.FanModeSequence, any>;
            percentCurrent: Attribute<number, any>;
            percentSetting: WritableAttribute<null | number, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    speedCurrent: Attribute<number, any>;
                    speedMax: FixedAttribute<number, any>;
                    speedSetting: WritableAttribute<null | number, any>;
                };
            };
            flags: {
                multiSpeed: true;
            };
        }, {
            component: {
                attributes: {
                    rockSetting: WritableAttribute<TypeFromPartialBitSchema<{
                        rockLeftRight: BitFlag;
                        rockRound: BitFlag;
                        rockUpDown: BitFlag;
                    }>, any>;
                    rockSupport: FixedAttribute<TypeFromPartialBitSchema<{
                        rockLeftRight: BitFlag;
                        rockRound: BitFlag;
                        rockUpDown: BitFlag;
                    }>, any>;
                };
            };
            flags: {
                rocking: true;
            };
        }, {
            component: {
                attributes: {
                    windSetting: WritableAttribute<TypeFromPartialBitSchema<{
                        naturalWind: BitFlag;
                        sleepWind: BitFlag;
                    }>, any>;
                    windSupport: FixedAttribute<TypeFromPartialBitSchema<{
                        naturalWind: BitFlag;
                        sleepWind: BitFlag;
                    }>, any>;
                };
            };
            flags: {
                wind: true;
            };
        }, {
            component: {
                attributes: {
                    airflowDirection: WritableAttribute<FanControl.AirflowDirection, any>;
                };
            };
            flags: {
                airflowDirection: true;
            };
        }, {
            component: {
                commands: {
                    step: Command<TypeFromFields<{
                        direction: FieldType<(...)>;
                        lowestOff: OptionalFieldType<(...)>;
                        wrap: OptionalFieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                step: true;
            };
        }];
        features: {
            airflowDirection: BitFlag;
            auto: BitFlag;
            multiSpeed: BitFlag;
            rocking: BitFlag;
            step: BitFlag;
            wind: BitFlag;
        };
        id: 514;
        name: "FanControl";
        revision: 4;
    }>, ValuesT>

  • Modify elements using ElementModifier.set.

    Type Parameters

    • const ValuesT extends {
          fanMode: number;
          fanModeSequence: number;
          percentCurrent: number;
          percentSetting: null | number;
      }

    Parameters

    Returns WithValues<Of<{
        attributes: {
            fanMode: WritableAttribute<FanControl.FanMode, any>;
            fanModeSequence: FixedAttribute<FanControl.FanModeSequence, any>;
            percentCurrent: Attribute<number, any>;
            percentSetting: WritableAttribute<null | number, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    speedCurrent: Attribute<number, any>;
                    speedMax: FixedAttribute<number, any>;
                    speedSetting: WritableAttribute<null | number, any>;
                };
            };
            flags: {
                multiSpeed: true;
            };
        }, {
            component: {
                attributes: {
                    rockSetting: WritableAttribute<TypeFromPartialBitSchema<{
                        rockLeftRight: BitFlag;
                        rockRound: BitFlag;
                        rockUpDown: BitFlag;
                    }>, any>;
                    rockSupport: FixedAttribute<TypeFromPartialBitSchema<{
                        rockLeftRight: BitFlag;
                        rockRound: BitFlag;
                        rockUpDown: BitFlag;
                    }>, any>;
                };
            };
            flags: {
                rocking: true;
            };
        }, {
            component: {
                attributes: {
                    windSetting: WritableAttribute<TypeFromPartialBitSchema<{
                        naturalWind: BitFlag;
                        sleepWind: BitFlag;
                    }>, any>;
                    windSupport: FixedAttribute<TypeFromPartialBitSchema<{
                        naturalWind: BitFlag;
                        sleepWind: BitFlag;
                    }>, any>;
                };
            };
            flags: {
                wind: true;
            };
        }, {
            component: {
                attributes: {
                    airflowDirection: WritableAttribute<FanControl.AirflowDirection, any>;
                };
            };
            flags: {
                airflowDirection: true;
            };
        }, {
            component: {
                commands: {
                    step: Command<TypeFromFields<{
                        direction: FieldType<(...)>;
                        lowestOff: OptionalFieldType<(...)>;
                        wrap: OptionalFieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                step: true;
            };
        }];
        features: {
            airflowDirection: BitFlag;
            auto: BitFlag;
            multiSpeed: BitFlag;
            rocking: BitFlag;
            step: BitFlag;
            wind: BitFlag;
        };
        id: 514;
        name: "FanControl";
        revision: 4;
    }>, ValuesT>

with

  • with<const SelectionT>(...selection): Of<Of<{
        attributes: {
            fanMode: WritableAttribute<FanControl.FanMode, any>;
            fanModeSequence: FixedAttribute<FanControl.FanModeSequence, any>;
            percentCurrent: Attribute<number, any>;
            percentSetting: WritableAttribute<null | number, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    speedCurrent: Attribute<number, any>;
                    speedMax: FixedAttribute<number, any>;
                    speedSetting: WritableAttribute<null | number, any>;
                };
            };
            flags: {
                multiSpeed: true;
            };
        }, {
            component: {
                attributes: {
                    rockSetting: WritableAttribute<TypeFromPartialBitSchema<{
                        rockLeftRight: BitFlag;
                        rockRound: BitFlag;
                        rockUpDown: BitFlag;
                    }>, any>;
                    rockSupport: FixedAttribute<TypeFromPartialBitSchema<{
                        rockLeftRight: BitFlag;
                        rockRound: BitFlag;
                        rockUpDown: BitFlag;
                    }>, any>;
                };
            };
            flags: {
                rocking: true;
            };
        }, {
            component: {
                attributes: {
                    windSetting: WritableAttribute<TypeFromPartialBitSchema<{
                        naturalWind: BitFlag;
                        sleepWind: BitFlag;
                    }>, any>;
                    windSupport: FixedAttribute<TypeFromPartialBitSchema<{
                        naturalWind: BitFlag;
                        sleepWind: BitFlag;
                    }>, any>;
                };
            };
            flags: {
                wind: true;
            };
        }, {
            component: {
                attributes: {
                    airflowDirection: WritableAttribute<FanControl.AirflowDirection, any>;
                };
            };
            flags: {
                airflowDirection: true;
            };
        }, {
            component: {
                commands: {
                    step: Command<TypeFromFields<{
                        direction: FieldType<(...)>;
                        lowestOff: OptionalFieldType<(...)>;
                        wrap: OptionalFieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                step: true;
            };
        }];
        features: {
            airflowDirection: BitFlag;
            auto: BitFlag;
            multiSpeed: BitFlag;
            rocking: BitFlag;
            step: BitFlag;
            wind: BitFlag;
        };
        id: 514;
        name: "FanControl";
        revision: 4;
    }>, SelectionT>

  • Select features using ClusterComposer.compose.

    Type Parameters

    • const SelectionT extends FeatureSelection<Of<{
          attributes: {
              fanMode: WritableAttribute<FanControl.FanMode, any>;
              fanModeSequence: FixedAttribute<FanControl.FanModeSequence, any>;
              percentCurrent: Attribute<number, any>;
              percentSetting: WritableAttribute<null | number, any>;
          };
          extensions: readonly [{
              component: {
                  attributes: {
                      speedCurrent: Attribute<number, any>;
                      speedMax: FixedAttribute<number, any>;
                      speedSetting: WritableAttribute<null | number, any>;
                  };
              };
              flags: {
                  multiSpeed: true;
              };
          }, {
              component: {
                  attributes: {
                      rockSetting: WritableAttribute<TypeFromPartialBitSchema<{
                          rockLeftRight: BitFlag;
                          rockRound: BitFlag;
                          rockUpDown: BitFlag;
                      }>, any>;
                      rockSupport: FixedAttribute<TypeFromPartialBitSchema<{
                          rockLeftRight: BitFlag;
                          rockRound: BitFlag;
                          rockUpDown: BitFlag;
                      }>, any>;
                  };
              };
              flags: {
                  rocking: true;
              };
          }, {
              component: {
                  attributes: {
                      windSetting: WritableAttribute<TypeFromPartialBitSchema<{
                          naturalWind: BitFlag;
                          sleepWind: BitFlag;
                      }>, any>;
                      windSupport: FixedAttribute<TypeFromPartialBitSchema<{
                          naturalWind: BitFlag;
                          sleepWind: BitFlag;
                      }>, any>;
                  };
              };
              flags: {
                  wind: true;
              };
          }, {
              component: {
                  attributes: {
                      airflowDirection: WritableAttribute<FanControl.AirflowDirection, any>;
                  };
              };
              flags: {
                  airflowDirection: true;
              };
          }, {
              component: {
                  commands: {
                      step: Command<TypeFromFields<{
                          direction: FieldType<(...)>;
                          lowestOff: OptionalFieldType<(...)>;
                          wrap: OptionalFieldType<(...)>;
                      }>, void, any>;
                  };
              };
              flags: {
                  step: true;
              };
          }];
          features: {
              airflowDirection: BitFlag;
              auto: BitFlag;
              multiSpeed: BitFlag;
              rocking: BitFlag;
              step: BitFlag;
              wind: BitFlag;
          };
          id: 514;
          name: "FanControl";
          revision: 4;
      }>>

    Parameters

    Returns Of<Of<{
        attributes: {
            fanMode: WritableAttribute<FanControl.FanMode, any>;
            fanModeSequence: FixedAttribute<FanControl.FanModeSequence, any>;
            percentCurrent: Attribute<number, any>;
            percentSetting: WritableAttribute<null | number, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    speedCurrent: Attribute<number, any>;
                    speedMax: FixedAttribute<number, any>;
                    speedSetting: WritableAttribute<null | number, any>;
                };
            };
            flags: {
                multiSpeed: true;
            };
        }, {
            component: {
                attributes: {
                    rockSetting: WritableAttribute<TypeFromPartialBitSchema<{
                        rockLeftRight: BitFlag;
                        rockRound: BitFlag;
                        rockUpDown: BitFlag;
                    }>, any>;
                    rockSupport: FixedAttribute<TypeFromPartialBitSchema<{
                        rockLeftRight: BitFlag;
                        rockRound: BitFlag;
                        rockUpDown: BitFlag;
                    }>, any>;
                };
            };
            flags: {
                rocking: true;
            };
        }, {
            component: {
                attributes: {
                    windSetting: WritableAttribute<TypeFromPartialBitSchema<{
                        naturalWind: BitFlag;
                        sleepWind: BitFlag;
                    }>, any>;
                    windSupport: FixedAttribute<TypeFromPartialBitSchema<{
                        naturalWind: BitFlag;
                        sleepWind: BitFlag;
                    }>, any>;
                };
            };
            flags: {
                wind: true;
            };
        }, {
            component: {
                attributes: {
                    airflowDirection: WritableAttribute<FanControl.AirflowDirection, any>;
                };
            };
            flags: {
                airflowDirection: true;
            };
        }, {
            component: {
                commands: {
                    step: Command<TypeFromFields<{
                        direction: FieldType<(...)>;
                        lowestOff: OptionalFieldType<(...)>;
                        wrap: OptionalFieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                step: true;
            };
        }];
        features: {
            airflowDirection: BitFlag;
            auto: BitFlag;
            multiSpeed: BitFlag;
            rocking: BitFlag;
            step: BitFlag;
            wind: BitFlag;
        };
        id: 514;
        name: "FanControl";
        revision: 4;
    }>, SelectionT>

Settings

Member Visibility

On This Page

Properties
Methods