Variable ThermostatBehaviorConst

ThermostatBehavior: Type<Of<{
    attributes: {
        acCapacity: OptionalWritableAttribute<number, any>;
        acCapacityFormat: OptionalWritableAttribute<BtUh, any>;
        acCoilTemperature: OptionalAttribute<null | number, any>;
        acCompressorType: OptionalWritableAttribute<Thermostat.AcCompressorType, any>;
        acErrorCode: OptionalWritableAttribute<TypeFromPartialBitSchema<{
            coilSensorFail: BitFlag;
            compressorFail: BitFlag;
            fanFail: BitFlag;
            outdoorSensorFail: BitFlag;
            roomSensorFail: BitFlag;
        }>, any>;
        acLouverPosition: OptionalWritableAttribute<Thermostat.AcLouverPosition, any>;
        acRefrigerantType: OptionalWritableAttribute<Thermostat.AcRefrigerantType, any>;
        acType: OptionalWritableAttribute<Thermostat.AcType, any>;
        controlSequenceOfOperation: WritableAttribute<Thermostat.ControlSequenceOfOperation, any>;
        emergencyHeatDelta: OptionalWritableAttribute<number, any>;
        localTemperature: Attribute<null | number, any>;
        outdoorTemperature: OptionalAttribute<null | number, any>;
        remoteSensing: OptionalWritableAttribute<TypeFromPartialBitSchema<{
            localTemperature: BitFlag;
            occupancy: BitFlag;
            outdoorTemperature: BitFlag;
        }>, any>;
        setpointChangeAmount: OptionalAttribute<null | number, any>;
        setpointChangeSource: OptionalAttribute<Thermostat.SetpointChangeSource, any>;
        setpointChangeSourceTimestamp: OptionalAttribute<number, any>;
        systemMode: WritableAttribute<Thermostat.SystemMode, any>;
        temperatureSetpointHold: OptionalWritableAttribute<Thermostat.TemperatureSetpointHold, any>;
        temperatureSetpointHoldDuration: OptionalWritableAttribute<null | number, any>;
        thermostatProgrammingOperationMode: OptionalWritableAttribute<TypeFromPartialBitSchema<{
            autoRecovery: BitFlag;
            economy: BitFlag;
            scheduleActive: BitFlag;
        }>, any>;
        thermostatRunningState: OptionalAttribute<TypeFromPartialBitSchema<{
            cool: BitFlag;
            coolStage2: BitFlag;
            fan: BitFlag;
            fanStage2: BitFlag;
            fanStage3: BitFlag;
            heat: BitFlag;
            heatStage2: BitFlag;
        }>, any>;
    };
    commands: {
        setpointRaiseLower: Command<TypeFromFields<{
            amount: FieldType<number>;
            mode: FieldType<Thermostat.SetpointRaiseLowerMode>;
        }>, void, any>;
    };
    extensions: readonly [{
        component: {
            attributes: {
                occupancy: Attribute<TypeFromPartialBitSchema<{
                    occupied: BitFlag;
                }>, any>;
            };
        };
        flags: {
            occupancy: true;
        };
    }, {
        component: {
            attributes: {
                absMaxHeatSetpointLimit: OptionalFixedAttribute<number, any>;
                absMinHeatSetpointLimit: OptionalFixedAttribute<number, any>;
                maxHeatSetpointLimit: OptionalWritableAttribute<number, any>;
                minHeatSetpointLimit: OptionalWritableAttribute<number, any>;
                occupiedHeatingSetpoint: WritableAttribute<number, any>;
                piHeatingDemand: OptionalAttribute<number, any>;
            };
        };
        flags: {
            heating: true;
        };
    }, {
        component: {
            attributes: {
                absMaxCoolSetpointLimit: OptionalFixedAttribute<number, any>;
                absMinCoolSetpointLimit: OptionalFixedAttribute<number, any>;
                maxCoolSetpointLimit: OptionalWritableAttribute<number, any>;
                minCoolSetpointLimit: OptionalWritableAttribute<number, any>;
                occupiedCoolingSetpoint: WritableAttribute<number, any>;
                piCoolingDemand: OptionalAttribute<number, any>;
            };
        };
        flags: {
            cooling: true;
        };
    }, {
        component: {
            attributes: {
                localTemperatureCalibration: OptionalWritableAttribute<number, any>;
            };
        };
        flags: {
            localTemperatureNotExposed: false;
        };
    }, {
        component: {
            attributes: {
                unoccupiedCoolingSetpoint: WritableAttribute<number, any>;
            };
        };
        flags: {
            cooling: true;
            occupancy: true;
        };
    }, {
        component: {
            attributes: {
                unoccupiedHeatingSetpoint: WritableAttribute<number, any>;
            };
        };
        flags: {
            heating: true;
            occupancy: true;
        };
    }, {
        component: {
            attributes: {
                minSetpointDeadBand: WritableAttribute<number, any>;
                thermostatRunningMode: OptionalAttribute<Thermostat.ThermostatRunningMode, any>;
            };
        };
        flags: {
            autoMode: true;
        };
    }, {
        component: {
            attributes: {
                numberOfDailyTransitions: FixedAttribute<number, any>;
                numberOfWeeklyTransitions: FixedAttribute<number, any>;
                startOfWeek: FixedAttribute<Thermostat.StartOfWeek, any>;
            };
            commands: {
                clearWeeklySchedule: Command<void, void, any>;
                getWeeklySchedule: Command<TypeFromFields<{
                    daysToReturn: FieldType<(...)>;
                    modeToReturn: FieldType<(...)>;
                }>, TypeFromFields<{
                    dayOfWeekForSequence: FieldType<(...)>;
                    modeForSequence: FieldType<(...)>;
                    numberOfTransitionsForSequence: FieldType<(...)>;
                    transitions: FieldType<(...)>;
                }>, any>;
                setWeeklySchedule: Command<TypeFromFields<{
                    dayOfWeekForSequence: FieldType<(...)>;
                    modeForSequence: FieldType<(...)>;
                    numberOfTransitionsForSequence: FieldType<(...)>;
                    transitions: FieldType<(...)>;
                }>, void, any>;
            };
        };
        flags: {
            scheduleConfiguration: true;
        };
    }, {
        component: {
            attributes: {
                occupiedSetback: WritableAttribute<null | number, any>;
                occupiedSetbackMax: FixedAttribute<null | number, any>;
                occupiedSetbackMin: FixedAttribute<null | number, any>;
            };
        };
        flags: {
            setback: true;
        };
    }, {
        component: {
            attributes: {
                unoccupiedSetback: WritableAttribute<null | number, any>;
                unoccupiedSetbackMax: FixedAttribute<null | number, any>;
                unoccupiedSetbackMin: FixedAttribute<null | number, any>;
            };
        };
        flags: {
            occupancy: true;
            setback: true;
        };
    }, {
        component: false;
        flags: {
            autoMode: true;
            heating: false;
        };
    }, {
        component: false;
        flags: {
            autoMode: true;
            cooling: false;
        };
    }, {
        component: false;
        flags: {
            cooling: false;
            heating: false;
        };
    }];
    features: {
        autoMode: BitFlag;
        cooling: BitFlag;
        heating: BitFlag;
        localTemperatureNotExposed: BitFlag;
        occupancy: BitFlag;
        scheduleConfiguration: BitFlag;
        setback: BitFlag;
    };
    id: 513;
    name: "Thermostat";
    revision: 6;
}>, Type<Of<{
    attributes: {};
    commands: {};
    events: {};
    id: 0;
    name: "Unknown";
    revision: 0;
}>, typeof ClusterBehavior, ThermostatInterface>, ThermostatInterface> = ...

ThermostatBehavior is the base class for objects that support interaction with Thermostat.Cluster.

Thermostat.Cluster requires you to enable one or more optional features. You can do so using ThermostatBehavior.with.

Settings

Member Visibility