Interface Complete

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

base

base: undefined

commands

commands: {
    step: Command<TypeFromFields<{
        direction: FieldType<FanControl.StepDirection>;
        lowestOff: OptionalFieldType<boolean>;
        wrap: OptionalFieldType<boolean>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            step: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
}

events

events: {}

extensions

extensions: undefined

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<Branded<514, "ClusterId">, "ClusterId">

name

name

revision

revision

supportedFeatures

supportedFeatures: {}

unknown

unknown

Methods

alter

  • alter<const AlterationsT>(alterations): WithAlterations<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            airflowDirection: WritableAttribute<FanControl.AirflowDirection, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    airflowDirection: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            attributeList: Attribute<AttributeId[], never>;
            clusterRevision: Attribute<number, never>;
            fanMode: WritableAttribute<FanControl.FanMode, any>;
            fanModeSequence: FixedAttribute<FanControl.FanModeSequence, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                airflowDirection: BitFlag;
                auto: BitFlag;
                multiSpeed: BitFlag;
                rocking: BitFlag;
                step: BitFlag;
                wind: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            percentCurrent: Attribute<number, any>;
            percentSetting: WritableAttribute<null | number, any>;
            rockSetting: WritableAttribute<TypeFromPartialBitSchema<{
                rockLeftRight: BitFlag;
                rockRound: BitFlag;
                rockUpDown: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rocking: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            rockSupport: FixedAttribute<TypeFromPartialBitSchema<{
                rockLeftRight: BitFlag;
                rockRound: BitFlag;
                rockUpDown: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rocking: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            speedCurrent: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    multiSpeed: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            speedMax: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    multiSpeed: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            speedSetting: WritableAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    multiSpeed: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            windSetting: WritableAttribute<TypeFromPartialBitSchema<{
                naturalWind: BitFlag;
                sleepWind: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wind: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            windSupport: FixedAttribute<TypeFromPartialBitSchema<{
                naturalWind: BitFlag;
                sleepWind: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wind: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            step: Command<TypeFromFields<{
                direction: FieldType<FanControl.StepDirection>;
                lowestOff: OptionalFieldType<boolean>;
                wrap: OptionalFieldType<boolean>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    step: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            airflowDirection: BitFlag;
            auto: BitFlag;
            multiSpeed: BitFlag;
            rocking: BitFlag;
            step: BitFlag;
            wind: BitFlag;
        };
        id: Branded<514, "ClusterId">;
        name: "FanControl";
        revision: 4;
    }>, AlterationsT>

  • Modify elements using ElementModifier.alter.

    Type Parameters

    • const AlterationsT extends Alterations<Of<{
          attributes: {
              acceptedCommandList: Attribute<CommandId[], never>;
              airflowDirection: WritableAttribute<FanControl.AirflowDirection, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      airflowDirection: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              attributeList: Attribute<AttributeId[], never>;
              clusterRevision: Attribute<number, never>;
              fanMode: WritableAttribute<FanControl.FanMode, any>;
              fanModeSequence: FixedAttribute<FanControl.FanModeSequence, any>;
              featureMap: Attribute<TypeFromPartialBitSchema<{
                  airflowDirection: BitFlag;
                  auto: BitFlag;
                  multiSpeed: BitFlag;
                  rocking: BitFlag;
                  step: BitFlag;
                  wind: BitFlag;
              }>, never>;
              generatedCommandList: Attribute<CommandId[], never>;
              percentCurrent: Attribute<number, any>;
              percentSetting: WritableAttribute<null | number, any>;
              rockSetting: WritableAttribute<TypeFromPartialBitSchema<{
                  rockLeftRight: BitFlag;
                  rockRound: BitFlag;
                  rockUpDown: BitFlag;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      rocking: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              rockSupport: FixedAttribute<TypeFromPartialBitSchema<{
                  rockLeftRight: BitFlag;
                  rockRound: BitFlag;
                  rockUpDown: BitFlag;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      rocking: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              speedCurrent: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      multiSpeed: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              speedMax: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      multiSpeed: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              speedSetting: WritableAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      multiSpeed: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              windSetting: WritableAttribute<TypeFromPartialBitSchema<{
                  naturalWind: BitFlag;
                  sleepWind: BitFlag;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      wind: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              windSupport: FixedAttribute<TypeFromPartialBitSchema<{
                  naturalWind: BitFlag;
                  sleepWind: BitFlag;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      wind: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          commands: {
              step: Command<TypeFromFields<{
                  direction: FieldType<FanControl.StepDirection>;
                  lowestOff: OptionalFieldType<boolean>;
                  wrap: OptionalFieldType<boolean>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      step: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          features: {
              airflowDirection: BitFlag;
              auto: BitFlag;
              multiSpeed: BitFlag;
              rocking: BitFlag;
              step: BitFlag;
              wind: BitFlag;
          };
          id: Branded<514, "ClusterId">;
          name: "FanControl";
          revision: 4;
      }>>

    Parameters

    Returns WithAlterations<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            airflowDirection: WritableAttribute<FanControl.AirflowDirection, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    airflowDirection: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            attributeList: Attribute<AttributeId[], never>;
            clusterRevision: Attribute<number, never>;
            fanMode: WritableAttribute<FanControl.FanMode, any>;
            fanModeSequence: FixedAttribute<FanControl.FanModeSequence, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                airflowDirection: BitFlag;
                auto: BitFlag;
                multiSpeed: BitFlag;
                rocking: BitFlag;
                step: BitFlag;
                wind: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            percentCurrent: Attribute<number, any>;
            percentSetting: WritableAttribute<null | number, any>;
            rockSetting: WritableAttribute<TypeFromPartialBitSchema<{
                rockLeftRight: BitFlag;
                rockRound: BitFlag;
                rockUpDown: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rocking: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            rockSupport: FixedAttribute<TypeFromPartialBitSchema<{
                rockLeftRight: BitFlag;
                rockRound: BitFlag;
                rockUpDown: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rocking: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            speedCurrent: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    multiSpeed: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            speedMax: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    multiSpeed: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            speedSetting: WritableAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    multiSpeed: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            windSetting: WritableAttribute<TypeFromPartialBitSchema<{
                naturalWind: BitFlag;
                sleepWind: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wind: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            windSupport: FixedAttribute<TypeFromPartialBitSchema<{
                naturalWind: BitFlag;
                sleepWind: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wind: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            step: Command<TypeFromFields<{
                direction: FieldType<FanControl.StepDirection>;
                lowestOff: OptionalFieldType<boolean>;
                wrap: OptionalFieldType<boolean>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    step: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            airflowDirection: BitFlag;
            auto: BitFlag;
            multiSpeed: BitFlag;
            rocking: BitFlag;
            step: BitFlag;
            wind: BitFlag;
        };
        id: Branded<514, "ClusterId">;
        name: "FanControl";
        revision: 4;
    }>, AlterationsT>

enable

  • enable<const FlagsT>(flags): WithFlags<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            airflowDirection: WritableAttribute<FanControl.AirflowDirection, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    airflowDirection: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            attributeList: Attribute<AttributeId[], never>;
            clusterRevision: Attribute<number, never>;
            fanMode: WritableAttribute<FanControl.FanMode, any>;
            fanModeSequence: FixedAttribute<FanControl.FanModeSequence, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                airflowDirection: BitFlag;
                auto: BitFlag;
                multiSpeed: BitFlag;
                rocking: BitFlag;
                step: BitFlag;
                wind: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            percentCurrent: Attribute<number, any>;
            percentSetting: WritableAttribute<null | number, any>;
            rockSetting: WritableAttribute<TypeFromPartialBitSchema<{
                rockLeftRight: BitFlag;
                rockRound: BitFlag;
                rockUpDown: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rocking: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            rockSupport: FixedAttribute<TypeFromPartialBitSchema<{
                rockLeftRight: BitFlag;
                rockRound: BitFlag;
                rockUpDown: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rocking: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            speedCurrent: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    multiSpeed: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            speedMax: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    multiSpeed: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            speedSetting: WritableAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    multiSpeed: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            windSetting: WritableAttribute<TypeFromPartialBitSchema<{
                naturalWind: BitFlag;
                sleepWind: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wind: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            windSupport: FixedAttribute<TypeFromPartialBitSchema<{
                naturalWind: BitFlag;
                sleepWind: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wind: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            step: Command<TypeFromFields<{
                direction: FieldType<FanControl.StepDirection>;
                lowestOff: OptionalFieldType<boolean>;
                wrap: OptionalFieldType<boolean>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    step: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            airflowDirection: BitFlag;
            auto: BitFlag;
            multiSpeed: BitFlag;
            rocking: BitFlag;
            step: BitFlag;
            wind: BitFlag;
        };
        id: Branded<514, "ClusterId">;
        name: "FanControl";
        revision: 4;
    }>, FlagsT>

  • Modify elements using ElementModifier.enable.

    Type Parameters

    • const FlagsT extends ElementFlags<Of<{
          attributes: {
              acceptedCommandList: Attribute<CommandId[], never>;
              airflowDirection: WritableAttribute<FanControl.AirflowDirection, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      airflowDirection: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              attributeList: Attribute<AttributeId[], never>;
              clusterRevision: Attribute<number, never>;
              fanMode: WritableAttribute<FanControl.FanMode, any>;
              fanModeSequence: FixedAttribute<FanControl.FanModeSequence, any>;
              featureMap: Attribute<TypeFromPartialBitSchema<{
                  airflowDirection: BitFlag;
                  auto: BitFlag;
                  multiSpeed: BitFlag;
                  rocking: BitFlag;
                  step: BitFlag;
                  wind: BitFlag;
              }>, never>;
              generatedCommandList: Attribute<CommandId[], never>;
              percentCurrent: Attribute<number, any>;
              percentSetting: WritableAttribute<null | number, any>;
              rockSetting: WritableAttribute<TypeFromPartialBitSchema<{
                  rockLeftRight: BitFlag;
                  rockRound: BitFlag;
                  rockUpDown: BitFlag;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      rocking: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              rockSupport: FixedAttribute<TypeFromPartialBitSchema<{
                  rockLeftRight: BitFlag;
                  rockRound: BitFlag;
                  rockUpDown: BitFlag;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      rocking: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              speedCurrent: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      multiSpeed: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              speedMax: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      multiSpeed: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              speedSetting: WritableAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      multiSpeed: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              windSetting: WritableAttribute<TypeFromPartialBitSchema<{
                  naturalWind: BitFlag;
                  sleepWind: BitFlag;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      wind: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              windSupport: FixedAttribute<TypeFromPartialBitSchema<{
                  naturalWind: BitFlag;
                  sleepWind: BitFlag;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      wind: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          commands: {
              step: Command<TypeFromFields<{
                  direction: FieldType<FanControl.StepDirection>;
                  lowestOff: OptionalFieldType<boolean>;
                  wrap: OptionalFieldType<boolean>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      step: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          features: {
              airflowDirection: BitFlag;
              auto: BitFlag;
              multiSpeed: BitFlag;
              rocking: BitFlag;
              step: BitFlag;
              wind: BitFlag;
          };
          id: Branded<514, "ClusterId">;
          name: "FanControl";
          revision: 4;
      }>>

    Parameters

    Returns WithFlags<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            airflowDirection: WritableAttribute<FanControl.AirflowDirection, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    airflowDirection: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            attributeList: Attribute<AttributeId[], never>;
            clusterRevision: Attribute<number, never>;
            fanMode: WritableAttribute<FanControl.FanMode, any>;
            fanModeSequence: FixedAttribute<FanControl.FanModeSequence, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                airflowDirection: BitFlag;
                auto: BitFlag;
                multiSpeed: BitFlag;
                rocking: BitFlag;
                step: BitFlag;
                wind: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            percentCurrent: Attribute<number, any>;
            percentSetting: WritableAttribute<null | number, any>;
            rockSetting: WritableAttribute<TypeFromPartialBitSchema<{
                rockLeftRight: BitFlag;
                rockRound: BitFlag;
                rockUpDown: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rocking: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            rockSupport: FixedAttribute<TypeFromPartialBitSchema<{
                rockLeftRight: BitFlag;
                rockRound: BitFlag;
                rockUpDown: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rocking: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            speedCurrent: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    multiSpeed: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            speedMax: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    multiSpeed: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            speedSetting: WritableAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    multiSpeed: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            windSetting: WritableAttribute<TypeFromPartialBitSchema<{
                naturalWind: BitFlag;
                sleepWind: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wind: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            windSupport: FixedAttribute<TypeFromPartialBitSchema<{
                naturalWind: BitFlag;
                sleepWind: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wind: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            step: Command<TypeFromFields<{
                direction: FieldType<FanControl.StepDirection>;
                lowestOff: OptionalFieldType<boolean>;
                wrap: OptionalFieldType<boolean>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    step: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            airflowDirection: BitFlag;
            auto: BitFlag;
            multiSpeed: BitFlag;
            rocking: BitFlag;
            step: BitFlag;
            wind: BitFlag;
        };
        id: Branded<514, "ClusterId">;
        name: "FanControl";
        revision: 4;
    }>, FlagsT>

set

  • set<const ValuesT>(values): WithValues<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            airflowDirection: WritableAttribute<FanControl.AirflowDirection, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    airflowDirection: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            attributeList: Attribute<AttributeId[], never>;
            clusterRevision: Attribute<number, never>;
            fanMode: WritableAttribute<FanControl.FanMode, any>;
            fanModeSequence: FixedAttribute<FanControl.FanModeSequence, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                airflowDirection: BitFlag;
                auto: BitFlag;
                multiSpeed: BitFlag;
                rocking: BitFlag;
                step: BitFlag;
                wind: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            percentCurrent: Attribute<number, any>;
            percentSetting: WritableAttribute<null | number, any>;
            rockSetting: WritableAttribute<TypeFromPartialBitSchema<{
                rockLeftRight: BitFlag;
                rockRound: BitFlag;
                rockUpDown: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rocking: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            rockSupport: FixedAttribute<TypeFromPartialBitSchema<{
                rockLeftRight: BitFlag;
                rockRound: BitFlag;
                rockUpDown: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rocking: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            speedCurrent: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    multiSpeed: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            speedMax: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    multiSpeed: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            speedSetting: WritableAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    multiSpeed: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            windSetting: WritableAttribute<TypeFromPartialBitSchema<{
                naturalWind: BitFlag;
                sleepWind: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wind: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            windSupport: FixedAttribute<TypeFromPartialBitSchema<{
                naturalWind: BitFlag;
                sleepWind: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wind: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            step: Command<TypeFromFields<{
                direction: FieldType<FanControl.StepDirection>;
                lowestOff: OptionalFieldType<boolean>;
                wrap: OptionalFieldType<boolean>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    step: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            airflowDirection: BitFlag;
            auto: BitFlag;
            multiSpeed: BitFlag;
            rocking: BitFlag;
            step: BitFlag;
            wind: BitFlag;
        };
        id: Branded<514, "ClusterId">;
        name: "FanControl";
        revision: 4;
    }>, ValuesT>

  • Modify elements using ElementModifier.set.

    Type Parameters

    • const ValuesT extends {
          airflowDirection?: number;
          fanMode: number;
          fanModeSequence: number;
          percentCurrent: number;
          percentSetting: null | number;
          rockSetting?: {
              rockLeftRight?: boolean;
              rockRound?: boolean;
              rockUpDown?: boolean;
          };
          rockSupport?: {
              rockLeftRight?: boolean;
              rockRound?: boolean;
              rockUpDown?: boolean;
          };
          speedCurrent?: number;
          speedMax?: number;
          speedSetting?: null | number;
          windSetting?: {
              naturalWind?: boolean;
              sleepWind?: boolean;
          };
          windSupport?: {
              naturalWind?: boolean;
              sleepWind?: boolean;
          };
      }

    Parameters

    Returns WithValues<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            airflowDirection: WritableAttribute<FanControl.AirflowDirection, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    airflowDirection: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            attributeList: Attribute<AttributeId[], never>;
            clusterRevision: Attribute<number, never>;
            fanMode: WritableAttribute<FanControl.FanMode, any>;
            fanModeSequence: FixedAttribute<FanControl.FanModeSequence, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                airflowDirection: BitFlag;
                auto: BitFlag;
                multiSpeed: BitFlag;
                rocking: BitFlag;
                step: BitFlag;
                wind: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            percentCurrent: Attribute<number, any>;
            percentSetting: WritableAttribute<null | number, any>;
            rockSetting: WritableAttribute<TypeFromPartialBitSchema<{
                rockLeftRight: BitFlag;
                rockRound: BitFlag;
                rockUpDown: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rocking: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            rockSupport: FixedAttribute<TypeFromPartialBitSchema<{
                rockLeftRight: BitFlag;
                rockRound: BitFlag;
                rockUpDown: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rocking: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            speedCurrent: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    multiSpeed: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            speedMax: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    multiSpeed: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            speedSetting: WritableAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    multiSpeed: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            windSetting: WritableAttribute<TypeFromPartialBitSchema<{
                naturalWind: BitFlag;
                sleepWind: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wind: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            windSupport: FixedAttribute<TypeFromPartialBitSchema<{
                naturalWind: BitFlag;
                sleepWind: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wind: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            step: Command<TypeFromFields<{
                direction: FieldType<FanControl.StepDirection>;
                lowestOff: OptionalFieldType<boolean>;
                wrap: OptionalFieldType<boolean>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    step: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            airflowDirection: BitFlag;
            auto: BitFlag;
            multiSpeed: BitFlag;
            rocking: BitFlag;
            step: BitFlag;
            wind: BitFlag;
        };
        id: Branded<514, "ClusterId">;
        name: "FanControl";
        revision: 4;
    }>, ValuesT>

with

  • with<const SelectionT>(...selection): Of<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            airflowDirection: WritableAttribute<FanControl.AirflowDirection, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    airflowDirection: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            attributeList: Attribute<AttributeId[], never>;
            clusterRevision: Attribute<number, never>;
            fanMode: WritableAttribute<FanControl.FanMode, any>;
            fanModeSequence: FixedAttribute<FanControl.FanModeSequence, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                airflowDirection: BitFlag;
                auto: BitFlag;
                multiSpeed: BitFlag;
                rocking: BitFlag;
                step: BitFlag;
                wind: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            percentCurrent: Attribute<number, any>;
            percentSetting: WritableAttribute<null | number, any>;
            rockSetting: WritableAttribute<TypeFromPartialBitSchema<{
                rockLeftRight: BitFlag;
                rockRound: BitFlag;
                rockUpDown: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rocking: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            rockSupport: FixedAttribute<TypeFromPartialBitSchema<{
                rockLeftRight: BitFlag;
                rockRound: BitFlag;
                rockUpDown: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rocking: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            speedCurrent: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    multiSpeed: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            speedMax: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    multiSpeed: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            speedSetting: WritableAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    multiSpeed: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            windSetting: WritableAttribute<TypeFromPartialBitSchema<{
                naturalWind: BitFlag;
                sleepWind: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wind: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            windSupport: FixedAttribute<TypeFromPartialBitSchema<{
                naturalWind: BitFlag;
                sleepWind: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wind: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            step: Command<TypeFromFields<{
                direction: FieldType<FanControl.StepDirection>;
                lowestOff: OptionalFieldType<boolean>;
                wrap: OptionalFieldType<boolean>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    step: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            airflowDirection: BitFlag;
            auto: BitFlag;
            multiSpeed: BitFlag;
            rocking: BitFlag;
            step: BitFlag;
            wind: BitFlag;
        };
        id: Branded<514, "ClusterId">;
        name: "FanControl";
        revision: 4;
    }>, SelectionT>

  • Select features using ClusterComposer.compose.

    Type Parameters

    • const SelectionT extends FeatureSelection<Of<{
          attributes: {
              acceptedCommandList: Attribute<CommandId[], never>;
              airflowDirection: WritableAttribute<FanControl.AirflowDirection, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      airflowDirection: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              attributeList: Attribute<AttributeId[], never>;
              clusterRevision: Attribute<number, never>;
              fanMode: WritableAttribute<FanControl.FanMode, any>;
              fanModeSequence: FixedAttribute<FanControl.FanModeSequence, any>;
              featureMap: Attribute<TypeFromPartialBitSchema<{
                  airflowDirection: BitFlag;
                  auto: BitFlag;
                  multiSpeed: BitFlag;
                  rocking: BitFlag;
                  step: BitFlag;
                  wind: BitFlag;
              }>, never>;
              generatedCommandList: Attribute<CommandId[], never>;
              percentCurrent: Attribute<number, any>;
              percentSetting: WritableAttribute<null | number, any>;
              rockSetting: WritableAttribute<TypeFromPartialBitSchema<{
                  rockLeftRight: BitFlag;
                  rockRound: BitFlag;
                  rockUpDown: BitFlag;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      rocking: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              rockSupport: FixedAttribute<TypeFromPartialBitSchema<{
                  rockLeftRight: BitFlag;
                  rockRound: BitFlag;
                  rockUpDown: BitFlag;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      rocking: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              speedCurrent: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      multiSpeed: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              speedMax: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      multiSpeed: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              speedSetting: WritableAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      multiSpeed: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              windSetting: WritableAttribute<TypeFromPartialBitSchema<{
                  naturalWind: BitFlag;
                  sleepWind: BitFlag;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      wind: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              windSupport: FixedAttribute<TypeFromPartialBitSchema<{
                  naturalWind: BitFlag;
                  sleepWind: BitFlag;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      wind: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          commands: {
              step: Command<TypeFromFields<{
                  direction: FieldType<FanControl.StepDirection>;
                  lowestOff: OptionalFieldType<boolean>;
                  wrap: OptionalFieldType<boolean>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      step: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          features: {
              airflowDirection: BitFlag;
              auto: BitFlag;
              multiSpeed: BitFlag;
              rocking: BitFlag;
              step: BitFlag;
              wind: BitFlag;
          };
          id: Branded<514, "ClusterId">;
          name: "FanControl";
          revision: 4;
      }>>

    Parameters

    Returns Of<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            airflowDirection: WritableAttribute<FanControl.AirflowDirection, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    airflowDirection: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            attributeList: Attribute<AttributeId[], never>;
            clusterRevision: Attribute<number, never>;
            fanMode: WritableAttribute<FanControl.FanMode, any>;
            fanModeSequence: FixedAttribute<FanControl.FanModeSequence, any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                airflowDirection: BitFlag;
                auto: BitFlag;
                multiSpeed: BitFlag;
                rocking: BitFlag;
                step: BitFlag;
                wind: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            percentCurrent: Attribute<number, any>;
            percentSetting: WritableAttribute<null | number, any>;
            rockSetting: WritableAttribute<TypeFromPartialBitSchema<{
                rockLeftRight: BitFlag;
                rockRound: BitFlag;
                rockUpDown: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rocking: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            rockSupport: FixedAttribute<TypeFromPartialBitSchema<{
                rockLeftRight: BitFlag;
                rockRound: BitFlag;
                rockUpDown: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rocking: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            speedCurrent: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    multiSpeed: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            speedMax: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    multiSpeed: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            speedSetting: WritableAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    multiSpeed: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            windSetting: WritableAttribute<TypeFromPartialBitSchema<{
                naturalWind: BitFlag;
                sleepWind: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wind: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            windSupport: FixedAttribute<TypeFromPartialBitSchema<{
                naturalWind: BitFlag;
                sleepWind: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wind: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            step: Command<TypeFromFields<{
                direction: FieldType<FanControl.StepDirection>;
                lowestOff: OptionalFieldType<boolean>;
                wrap: OptionalFieldType<boolean>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    step: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            airflowDirection: BitFlag;
            auto: BitFlag;
            multiSpeed: BitFlag;
            rocking: BitFlag;
            step: BitFlag;
            wind: BitFlag;
        };
        id: Branded<514, "ClusterId">;
        name: "FanControl";
        revision: 4;
    }>, SelectionT>

Settings

Member Visibility

On This Page

Properties
Methods