This cluster supports all Thermostat 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<{
        absMaxCoolSetpointLimit: OptionalFixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                cooling: boolean;
            }];
        };
        absMaxHeatSetpointLimit: OptionalFixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                heating: boolean;
            }];
        };
        absMinCoolSetpointLimit: OptionalFixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                cooling: boolean;
            }];
        };
        absMinHeatSetpointLimit: OptionalFixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                heating: boolean;
            }];
        };
        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>;
        localTemperatureCalibration: OptionalWritableAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [];
        };
        maxCoolSetpointLimit: OptionalWritableAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                cooling: boolean;
            }];
        };
        maxHeatSetpointLimit: OptionalWritableAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                heating: boolean;
            }];
        };
        minCoolSetpointLimit: OptionalWritableAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                cooling: boolean;
            }];
        };
        minHeatSetpointLimit: OptionalWritableAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                heating: boolean;
            }];
        };
        minSetpointDeadBand: WritableAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                autoMode: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        numberOfDailyTransitions: FixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                scheduleConfiguration: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        numberOfWeeklyTransitions: FixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                scheduleConfiguration: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        occupancy: Attribute<TypeFromPartialBitSchema<{
            occupied: BitFlag;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                occupancy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        occupiedCoolingSetpoint: WritableAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                cooling: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        occupiedHeatingSetpoint: WritableAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                heating: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        occupiedSetback: WritableAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                setback: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        occupiedSetbackMax: FixedAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                setback: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        occupiedSetbackMin: FixedAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                setback: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        outdoorTemperature: OptionalAttribute<null | number, any>;
        piCoolingDemand: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                cooling: boolean;
            }];
        };
        piHeatingDemand: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                heating: boolean;
            }];
        };
        remoteSensing: OptionalWritableAttribute<TypeFromPartialBitSchema<{
            localTemperature: BitFlag;
            occupancy: BitFlag;
            outdoorTemperature: BitFlag;
        }>, any>;
        setpointChangeAmount: OptionalAttribute<null | number, any>;
        setpointChangeSource: OptionalAttribute<Thermostat.SetpointChangeSource, any>;
        setpointChangeSourceTimestamp: OptionalAttribute<number, any>;
        startOfWeek: FixedAttribute<Thermostat.StartOfWeek, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                scheduleConfiguration: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        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>;
        thermostatRunningMode: OptionalAttribute<Thermostat.ThermostatRunningMode, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                autoMode: boolean;
            }];
        };
        thermostatRunningState: OptionalAttribute<TypeFromPartialBitSchema<{
            cool: BitFlag;
            coolStage2: BitFlag;
            fan: BitFlag;
            fanStage2: BitFlag;
            fanStage3: BitFlag;
            heat: BitFlag;
            heatStage2: BitFlag;
        }>, any>;
        unoccupiedCoolingSetpoint: WritableAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                cooling: boolean;
                occupancy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        unoccupiedHeatingSetpoint: WritableAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                heating: boolean;
                occupancy: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        unoccupiedSetback: WritableAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                occupancy: boolean;
                setback: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        unoccupiedSetbackMax: FixedAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                occupancy: boolean;
                setback: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        unoccupiedSetbackMin: FixedAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                occupancy: boolean;
                setback: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    }, GlobalAttributes<{
        autoMode: BitFlag;
        cooling: BitFlag;
        heating: BitFlag;
        localTemperatureNotExposed: BitFlag;
        occupancy: BitFlag;
        scheduleConfiguration: BitFlag;
        setback: BitFlag;
    }>>;
    base: undefined;
    commands: {
        clearWeeklySchedule: Command<void, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                scheduleConfiguration: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        getWeeklySchedule: Command<TypeFromFields<{
            daysToReturn: FieldType<TypeFromPartialBitSchema<{
                away: BitFlag;
                friday: BitFlag;
                monday: BitFlag;
                saturday: BitFlag;
                sunday: BitFlag;
                thursday: BitFlag;
                tuesday: BitFlag;
                wednesday: BitFlag;
            }>>;
            modeToReturn: FieldType<TypeFromPartialBitSchema<{
                coolSetpointPresent: BitFlag;
                heatSetpointPresent: BitFlag;
            }>>;
        }>, TypeFromFields<{
            dayOfWeekForSequence: FieldType<TypeFromPartialBitSchema<{
                away: BitFlag;
                friday: BitFlag;
                monday: BitFlag;
                saturday: BitFlag;
                sunday: BitFlag;
                thursday: BitFlag;
                tuesday: BitFlag;
                wednesday: BitFlag;
            }>>;
            modeForSequence: FieldType<TypeFromPartialBitSchema<{
                coolSetpointPresent: BitFlag;
                heatSetpointPresent: BitFlag;
            }>>;
            numberOfTransitionsForSequence: FieldType<number>;
            transitions: FieldType<TypeFromFields<{
                coolSetpoint: FieldType<(...) | (...)>;
                heatSetpoint: FieldType<(...) | (...)>;
                transitionTime: FieldType<number>;
            }>[]>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                scheduleConfiguration: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        setpointRaiseLower: Command<TypeFromFields<{
            amount: FieldType<number>;
            mode: FieldType<Thermostat.SetpointRaiseLowerMode>;
        }>, void, any>;
        setWeeklySchedule: Command<TypeFromFields<{
            dayOfWeekForSequence: FieldType<TypeFromPartialBitSchema<{
                away: BitFlag;
                friday: BitFlag;
                monday: BitFlag;
                saturday: BitFlag;
                sunday: BitFlag;
                thursday: BitFlag;
                tuesday: BitFlag;
                wednesday: BitFlag;
            }>>;
            modeForSequence: FieldType<TypeFromPartialBitSchema<{
                coolSetpointPresent: BitFlag;
                heatSetpointPresent: BitFlag;
            }>>;
            numberOfTransitionsForSequence: FieldType<number>;
            transitions: FieldType<TypeFromFields<{
                coolSetpoint: FieldType<(...) | (...)>;
                heatSetpoint: FieldType<(...) | (...)>;
                transitionTime: FieldType<number>;
            }>[]>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                scheduleConfiguration: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    events: {};
    extensions: undefined;
    features: {
        autoMode: BitFlag;
        cooling: BitFlag;
        heating: BitFlag;
        localTemperatureNotExposed: BitFlag;
        occupancy: BitFlag;
        scheduleConfiguration: BitFlag;
        setback: BitFlag;
    };
    id: Branded<513, "ClusterId">;
    name: "Thermostat";
    revision: 6;
    supportedFeatures: {};
    unknown: false;
    alter<const AlterationsT>(alterations: AlterationsT): WithAlterations<Of<{
        attributes: {
            absMaxCoolSetpointLimit: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    cooling: boolean;
                }];
            };
            absMaxHeatSetpointLimit: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    heating: boolean;
                }];
            };
            absMinCoolSetpointLimit: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    cooling: boolean;
                }];
            };
            absMinHeatSetpointLimit: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    heating: boolean;
                }];
            };
            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>;
            localTemperatureCalibration: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [];
            };
            maxCoolSetpointLimit: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    cooling: boolean;
                }];
            };
            maxHeatSetpointLimit: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    heating: boolean;
                }];
            };
            minCoolSetpointLimit: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    cooling: boolean;
                }];
            };
            minHeatSetpointLimit: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    heating: boolean;
                }];
            };
            minSetpointDeadBand: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    autoMode: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfDailyTransitions: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    scheduleConfiguration: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfWeeklyTransitions: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    scheduleConfiguration: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            occupancy: Attribute<TypeFromPartialBitSchema<{
                occupied: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    occupancy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            occupiedCoolingSetpoint: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    cooling: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            occupiedHeatingSetpoint: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    heating: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            occupiedSetback: WritableAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    setback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            occupiedSetbackMax: FixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    setback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            occupiedSetbackMin: FixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    setback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            outdoorTemperature: OptionalAttribute<null | number, any>;
            piCoolingDemand: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    cooling: boolean;
                }];
            };
            piHeatingDemand: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    heating: boolean;
                }];
            };
            remoteSensing: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                localTemperature: BitFlag;
                occupancy: BitFlag;
                outdoorTemperature: BitFlag;
            }>, any>;
            setpointChangeAmount: OptionalAttribute<null | number, any>;
            setpointChangeSource: OptionalAttribute<Thermostat.SetpointChangeSource, any>;
            setpointChangeSourceTimestamp: OptionalAttribute<number, any>;
            startOfWeek: FixedAttribute<Thermostat.StartOfWeek, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    scheduleConfiguration: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            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>;
            thermostatRunningMode: OptionalAttribute<Thermostat.ThermostatRunningMode, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    autoMode: boolean;
                }];
            };
            thermostatRunningState: OptionalAttribute<TypeFromPartialBitSchema<{
                cool: BitFlag;
                coolStage2: BitFlag;
                fan: BitFlag;
                fanStage2: BitFlag;
                fanStage3: BitFlag;
                heat: BitFlag;
                heatStage2: BitFlag;
            }>, any>;
            unoccupiedCoolingSetpoint: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    cooling: boolean;
                    occupancy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unoccupiedHeatingSetpoint: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    heating: boolean;
                    occupancy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unoccupiedSetback: WritableAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    occupancy: boolean;
                    setback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unoccupiedSetbackMax: FixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    occupancy: boolean;
                    setback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unoccupiedSetbackMin: FixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    occupancy: boolean;
                    setback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            clearWeeklySchedule: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    scheduleConfiguration: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getWeeklySchedule: Command<TypeFromFields<{
                daysToReturn: FieldType<TypeFromPartialBitSchema<{
                    away: ...;
                    friday: ...;
                    monday: ...;
                    saturday: ...;
                    sunday: ...;
                    thursday: ...;
                    tuesday: ...;
                    wednesday: ...;
                }>>;
                modeToReturn: FieldType<TypeFromPartialBitSchema<{
                    coolSetpointPresent: ...;
                    heatSetpointPresent: ...;
                }>>;
            }>, TypeFromFields<{
                dayOfWeekForSequence: FieldType<TypeFromPartialBitSchema<{
                    away: ...;
                    friday: ...;
                    monday: ...;
                    saturday: ...;
                    sunday: ...;
                    thursday: ...;
                    tuesday: ...;
                    wednesday: ...;
                }>>;
                modeForSequence: FieldType<TypeFromPartialBitSchema<{
                    coolSetpointPresent: ...;
                    heatSetpointPresent: ...;
                }>>;
                numberOfTransitionsForSequence: FieldType<number>;
                transitions: FieldType<TypeFromFields<(...)>[]>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    scheduleConfiguration: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setpointRaiseLower: Command<TypeFromFields<{
                amount: FieldType<number>;
                mode: FieldType<Thermostat.SetpointRaiseLowerMode>;
            }>, void, any>;
            setWeeklySchedule: Command<TypeFromFields<{
                dayOfWeekForSequence: FieldType<TypeFromPartialBitSchema<{
                    away: ...;
                    friday: ...;
                    monday: ...;
                    saturday: ...;
                    sunday: ...;
                    thursday: ...;
                    tuesday: ...;
                    wednesday: ...;
                }>>;
                modeForSequence: FieldType<TypeFromPartialBitSchema<{
                    coolSetpointPresent: ...;
                    heatSetpointPresent: ...;
                }>>;
                numberOfTransitionsForSequence: FieldType<number>;
                transitions: FieldType<TypeFromFields<(...)>[]>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    scheduleConfiguration: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            autoMode: BitFlag;
            cooling: BitFlag;
            heating: BitFlag;
            localTemperatureNotExposed: BitFlag;
            occupancy: BitFlag;
            scheduleConfiguration: BitFlag;
            setback: BitFlag;
        };
        id: 513;
        name: "Thermostat";
        revision: 6;
    }>, AlterationsT>;
    enable<const FlagsT>(flags: FlagsT): WithFlags<Of<{
        attributes: {
            absMaxCoolSetpointLimit: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    cooling: boolean;
                }];
            };
            absMaxHeatSetpointLimit: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    heating: boolean;
                }];
            };
            absMinCoolSetpointLimit: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    cooling: boolean;
                }];
            };
            absMinHeatSetpointLimit: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    heating: boolean;
                }];
            };
            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>;
            localTemperatureCalibration: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [];
            };
            maxCoolSetpointLimit: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    cooling: boolean;
                }];
            };
            maxHeatSetpointLimit: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    heating: boolean;
                }];
            };
            minCoolSetpointLimit: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    cooling: boolean;
                }];
            };
            minHeatSetpointLimit: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    heating: boolean;
                }];
            };
            minSetpointDeadBand: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    autoMode: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfDailyTransitions: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    scheduleConfiguration: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfWeeklyTransitions: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    scheduleConfiguration: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            occupancy: Attribute<TypeFromPartialBitSchema<{
                occupied: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    occupancy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            occupiedCoolingSetpoint: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    cooling: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            occupiedHeatingSetpoint: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    heating: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            occupiedSetback: WritableAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    setback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            occupiedSetbackMax: FixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    setback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            occupiedSetbackMin: FixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    setback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            outdoorTemperature: OptionalAttribute<null | number, any>;
            piCoolingDemand: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    cooling: boolean;
                }];
            };
            piHeatingDemand: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    heating: boolean;
                }];
            };
            remoteSensing: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                localTemperature: BitFlag;
                occupancy: BitFlag;
                outdoorTemperature: BitFlag;
            }>, any>;
            setpointChangeAmount: OptionalAttribute<null | number, any>;
            setpointChangeSource: OptionalAttribute<Thermostat.SetpointChangeSource, any>;
            setpointChangeSourceTimestamp: OptionalAttribute<number, any>;
            startOfWeek: FixedAttribute<Thermostat.StartOfWeek, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    scheduleConfiguration: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            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>;
            thermostatRunningMode: OptionalAttribute<Thermostat.ThermostatRunningMode, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    autoMode: boolean;
                }];
            };
            thermostatRunningState: OptionalAttribute<TypeFromPartialBitSchema<{
                cool: BitFlag;
                coolStage2: BitFlag;
                fan: BitFlag;
                fanStage2: BitFlag;
                fanStage3: BitFlag;
                heat: BitFlag;
                heatStage2: BitFlag;
            }>, any>;
            unoccupiedCoolingSetpoint: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    cooling: boolean;
                    occupancy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unoccupiedHeatingSetpoint: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    heating: boolean;
                    occupancy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unoccupiedSetback: WritableAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    occupancy: boolean;
                    setback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unoccupiedSetbackMax: FixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    occupancy: boolean;
                    setback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unoccupiedSetbackMin: FixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    occupancy: boolean;
                    setback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            clearWeeklySchedule: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    scheduleConfiguration: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getWeeklySchedule: Command<TypeFromFields<{
                daysToReturn: FieldType<TypeFromPartialBitSchema<{
                    away: ...;
                    friday: ...;
                    monday: ...;
                    saturday: ...;
                    sunday: ...;
                    thursday: ...;
                    tuesday: ...;
                    wednesday: ...;
                }>>;
                modeToReturn: FieldType<TypeFromPartialBitSchema<{
                    coolSetpointPresent: ...;
                    heatSetpointPresent: ...;
                }>>;
            }>, TypeFromFields<{
                dayOfWeekForSequence: FieldType<TypeFromPartialBitSchema<{
                    away: ...;
                    friday: ...;
                    monday: ...;
                    saturday: ...;
                    sunday: ...;
                    thursday: ...;
                    tuesday: ...;
                    wednesday: ...;
                }>>;
                modeForSequence: FieldType<TypeFromPartialBitSchema<{
                    coolSetpointPresent: ...;
                    heatSetpointPresent: ...;
                }>>;
                numberOfTransitionsForSequence: FieldType<number>;
                transitions: FieldType<TypeFromFields<(...)>[]>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    scheduleConfiguration: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setpointRaiseLower: Command<TypeFromFields<{
                amount: FieldType<number>;
                mode: FieldType<Thermostat.SetpointRaiseLowerMode>;
            }>, void, any>;
            setWeeklySchedule: Command<TypeFromFields<{
                dayOfWeekForSequence: FieldType<TypeFromPartialBitSchema<{
                    away: ...;
                    friday: ...;
                    monday: ...;
                    saturday: ...;
                    sunday: ...;
                    thursday: ...;
                    tuesday: ...;
                    wednesday: ...;
                }>>;
                modeForSequence: FieldType<TypeFromPartialBitSchema<{
                    coolSetpointPresent: ...;
                    heatSetpointPresent: ...;
                }>>;
                numberOfTransitionsForSequence: FieldType<number>;
                transitions: FieldType<TypeFromFields<(...)>[]>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    scheduleConfiguration: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            autoMode: BitFlag;
            cooling: BitFlag;
            heating: BitFlag;
            localTemperatureNotExposed: BitFlag;
            occupancy: BitFlag;
            scheduleConfiguration: BitFlag;
            setback: BitFlag;
        };
        id: 513;
        name: "Thermostat";
        revision: 6;
    }>, FlagsT>;
    set<const ValuesT>(values: ValuesT): WithValues<Of<{
        attributes: {
            absMaxCoolSetpointLimit: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    cooling: boolean;
                }];
            };
            absMaxHeatSetpointLimit: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    heating: boolean;
                }];
            };
            absMinCoolSetpointLimit: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    cooling: boolean;
                }];
            };
            absMinHeatSetpointLimit: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    heating: boolean;
                }];
            };
            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>;
            localTemperatureCalibration: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [];
            };
            maxCoolSetpointLimit: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    cooling: boolean;
                }];
            };
            maxHeatSetpointLimit: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    heating: boolean;
                }];
            };
            minCoolSetpointLimit: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    cooling: boolean;
                }];
            };
            minHeatSetpointLimit: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    heating: boolean;
                }];
            };
            minSetpointDeadBand: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    autoMode: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfDailyTransitions: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    scheduleConfiguration: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfWeeklyTransitions: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    scheduleConfiguration: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            occupancy: Attribute<TypeFromPartialBitSchema<{
                occupied: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    occupancy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            occupiedCoolingSetpoint: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    cooling: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            occupiedHeatingSetpoint: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    heating: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            occupiedSetback: WritableAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    setback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            occupiedSetbackMax: FixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    setback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            occupiedSetbackMin: FixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    setback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            outdoorTemperature: OptionalAttribute<null | number, any>;
            piCoolingDemand: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    cooling: boolean;
                }];
            };
            piHeatingDemand: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    heating: boolean;
                }];
            };
            remoteSensing: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                localTemperature: BitFlag;
                occupancy: BitFlag;
                outdoorTemperature: BitFlag;
            }>, any>;
            setpointChangeAmount: OptionalAttribute<null | number, any>;
            setpointChangeSource: OptionalAttribute<Thermostat.SetpointChangeSource, any>;
            setpointChangeSourceTimestamp: OptionalAttribute<number, any>;
            startOfWeek: FixedAttribute<Thermostat.StartOfWeek, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    scheduleConfiguration: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            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>;
            thermostatRunningMode: OptionalAttribute<Thermostat.ThermostatRunningMode, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    autoMode: boolean;
                }];
            };
            thermostatRunningState: OptionalAttribute<TypeFromPartialBitSchema<{
                cool: BitFlag;
                coolStage2: BitFlag;
                fan: BitFlag;
                fanStage2: BitFlag;
                fanStage3: BitFlag;
                heat: BitFlag;
                heatStage2: BitFlag;
            }>, any>;
            unoccupiedCoolingSetpoint: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    cooling: boolean;
                    occupancy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unoccupiedHeatingSetpoint: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    heating: boolean;
                    occupancy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unoccupiedSetback: WritableAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    occupancy: boolean;
                    setback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unoccupiedSetbackMax: FixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    occupancy: boolean;
                    setback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unoccupiedSetbackMin: FixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    occupancy: boolean;
                    setback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            clearWeeklySchedule: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    scheduleConfiguration: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getWeeklySchedule: Command<TypeFromFields<{
                daysToReturn: FieldType<TypeFromPartialBitSchema<{
                    away: ...;
                    friday: ...;
                    monday: ...;
                    saturday: ...;
                    sunday: ...;
                    thursday: ...;
                    tuesday: ...;
                    wednesday: ...;
                }>>;
                modeToReturn: FieldType<TypeFromPartialBitSchema<{
                    coolSetpointPresent: ...;
                    heatSetpointPresent: ...;
                }>>;
            }>, TypeFromFields<{
                dayOfWeekForSequence: FieldType<TypeFromPartialBitSchema<{
                    away: ...;
                    friday: ...;
                    monday: ...;
                    saturday: ...;
                    sunday: ...;
                    thursday: ...;
                    tuesday: ...;
                    wednesday: ...;
                }>>;
                modeForSequence: FieldType<TypeFromPartialBitSchema<{
                    coolSetpointPresent: ...;
                    heatSetpointPresent: ...;
                }>>;
                numberOfTransitionsForSequence: FieldType<number>;
                transitions: FieldType<TypeFromFields<(...)>[]>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    scheduleConfiguration: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setpointRaiseLower: Command<TypeFromFields<{
                amount: FieldType<number>;
                mode: FieldType<Thermostat.SetpointRaiseLowerMode>;
            }>, void, any>;
            setWeeklySchedule: Command<TypeFromFields<{
                dayOfWeekForSequence: FieldType<TypeFromPartialBitSchema<{
                    away: ...;
                    friday: ...;
                    monday: ...;
                    saturday: ...;
                    sunday: ...;
                    thursday: ...;
                    tuesday: ...;
                    wednesday: ...;
                }>>;
                modeForSequence: FieldType<TypeFromPartialBitSchema<{
                    coolSetpointPresent: ...;
                    heatSetpointPresent: ...;
                }>>;
                numberOfTransitionsForSequence: FieldType<number>;
                transitions: FieldType<TypeFromFields<(...)>[]>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    scheduleConfiguration: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            autoMode: BitFlag;
            cooling: BitFlag;
            heating: BitFlag;
            localTemperatureNotExposed: BitFlag;
            occupancy: BitFlag;
            scheduleConfiguration: BitFlag;
            setback: BitFlag;
        };
        id: 513;
        name: "Thermostat";
        revision: 6;
    }>, ValuesT>;
    with<const SelectionT>(...selection: SelectionT): Of<Of<{
        attributes: {
            absMaxCoolSetpointLimit: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    cooling: boolean;
                }];
            };
            absMaxHeatSetpointLimit: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    heating: boolean;
                }];
            };
            absMinCoolSetpointLimit: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    cooling: boolean;
                }];
            };
            absMinHeatSetpointLimit: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    heating: boolean;
                }];
            };
            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>;
            localTemperatureCalibration: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [];
            };
            maxCoolSetpointLimit: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    cooling: boolean;
                }];
            };
            maxHeatSetpointLimit: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    heating: boolean;
                }];
            };
            minCoolSetpointLimit: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    cooling: boolean;
                }];
            };
            minHeatSetpointLimit: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    heating: boolean;
                }];
            };
            minSetpointDeadBand: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    autoMode: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfDailyTransitions: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    scheduleConfiguration: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfWeeklyTransitions: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    scheduleConfiguration: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            occupancy: Attribute<TypeFromPartialBitSchema<{
                occupied: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    occupancy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            occupiedCoolingSetpoint: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    cooling: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            occupiedHeatingSetpoint: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    heating: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            occupiedSetback: WritableAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    setback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            occupiedSetbackMax: FixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    setback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            occupiedSetbackMin: FixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    setback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            outdoorTemperature: OptionalAttribute<null | number, any>;
            piCoolingDemand: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    cooling: boolean;
                }];
            };
            piHeatingDemand: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    heating: boolean;
                }];
            };
            remoteSensing: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                localTemperature: BitFlag;
                occupancy: BitFlag;
                outdoorTemperature: BitFlag;
            }>, any>;
            setpointChangeAmount: OptionalAttribute<null | number, any>;
            setpointChangeSource: OptionalAttribute<Thermostat.SetpointChangeSource, any>;
            setpointChangeSourceTimestamp: OptionalAttribute<number, any>;
            startOfWeek: FixedAttribute<Thermostat.StartOfWeek, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    scheduleConfiguration: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            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>;
            thermostatRunningMode: OptionalAttribute<Thermostat.ThermostatRunningMode, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    autoMode: boolean;
                }];
            };
            thermostatRunningState: OptionalAttribute<TypeFromPartialBitSchema<{
                cool: BitFlag;
                coolStage2: BitFlag;
                fan: BitFlag;
                fanStage2: BitFlag;
                fanStage3: BitFlag;
                heat: BitFlag;
                heatStage2: BitFlag;
            }>, any>;
            unoccupiedCoolingSetpoint: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    cooling: boolean;
                    occupancy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unoccupiedHeatingSetpoint: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    heating: boolean;
                    occupancy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unoccupiedSetback: WritableAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    occupancy: boolean;
                    setback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unoccupiedSetbackMax: FixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    occupancy: boolean;
                    setback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unoccupiedSetbackMin: FixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    occupancy: boolean;
                    setback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            clearWeeklySchedule: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    scheduleConfiguration: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getWeeklySchedule: Command<TypeFromFields<{
                daysToReturn: FieldType<TypeFromPartialBitSchema<{
                    away: ...;
                    friday: ...;
                    monday: ...;
                    saturday: ...;
                    sunday: ...;
                    thursday: ...;
                    tuesday: ...;
                    wednesday: ...;
                }>>;
                modeToReturn: FieldType<TypeFromPartialBitSchema<{
                    coolSetpointPresent: ...;
                    heatSetpointPresent: ...;
                }>>;
            }>, TypeFromFields<{
                dayOfWeekForSequence: FieldType<TypeFromPartialBitSchema<{
                    away: ...;
                    friday: ...;
                    monday: ...;
                    saturday: ...;
                    sunday: ...;
                    thursday: ...;
                    tuesday: ...;
                    wednesday: ...;
                }>>;
                modeForSequence: FieldType<TypeFromPartialBitSchema<{
                    coolSetpointPresent: ...;
                    heatSetpointPresent: ...;
                }>>;
                numberOfTransitionsForSequence: FieldType<number>;
                transitions: FieldType<TypeFromFields<(...)>[]>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    scheduleConfiguration: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setpointRaiseLower: Command<TypeFromFields<{
                amount: FieldType<number>;
                mode: FieldType<Thermostat.SetpointRaiseLowerMode>;
            }>, void, any>;
            setWeeklySchedule: Command<TypeFromFields<{
                dayOfWeekForSequence: FieldType<TypeFromPartialBitSchema<{
                    away: ...;
                    friday: ...;
                    monday: ...;
                    saturday: ...;
                    sunday: ...;
                    thursday: ...;
                    tuesday: ...;
                    wednesday: ...;
                }>>;
                modeForSequence: FieldType<TypeFromPartialBitSchema<{
                    coolSetpointPresent: ...;
                    heatSetpointPresent: ...;
                }>>;
                numberOfTransitionsForSequence: FieldType<number>;
                transitions: FieldType<TypeFromFields<(...)>[]>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    scheduleConfiguration: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            autoMode: BitFlag;
            cooling: BitFlag;
            heating: BitFlag;
            localTemperatureNotExposed: BitFlag;
            occupancy: BitFlag;
            scheduleConfiguration: BitFlag;
            setback: BitFlag;
        };
        id: 513;
        name: "Thermostat";
        revision: 6;
    }>, SelectionT>;
}

Hierarchy (view full)

Properties

attributes: Merge<{
    absMaxCoolSetpointLimit: OptionalFixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            cooling: boolean;
        }];
    };
    absMaxHeatSetpointLimit: OptionalFixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            heating: boolean;
        }];
    };
    absMinCoolSetpointLimit: OptionalFixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            cooling: boolean;
        }];
    };
    absMinHeatSetpointLimit: OptionalFixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            heating: boolean;
        }];
    };
    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>;
    localTemperatureCalibration: OptionalWritableAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [];
    };
    maxCoolSetpointLimit: OptionalWritableAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            cooling: boolean;
        }];
    };
    maxHeatSetpointLimit: OptionalWritableAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            heating: boolean;
        }];
    };
    minCoolSetpointLimit: OptionalWritableAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            cooling: boolean;
        }];
    };
    minHeatSetpointLimit: OptionalWritableAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            heating: boolean;
        }];
    };
    minSetpointDeadBand: WritableAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            autoMode: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    numberOfDailyTransitions: FixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            scheduleConfiguration: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    numberOfWeeklyTransitions: FixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            scheduleConfiguration: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    occupancy: Attribute<TypeFromPartialBitSchema<{
        occupied: BitFlag;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            occupancy: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    occupiedCoolingSetpoint: WritableAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            cooling: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    occupiedHeatingSetpoint: WritableAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            heating: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    occupiedSetback: WritableAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            setback: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    occupiedSetbackMax: FixedAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            setback: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    occupiedSetbackMin: FixedAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            setback: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    outdoorTemperature: OptionalAttribute<null | number, any>;
    piCoolingDemand: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            cooling: boolean;
        }];
    };
    piHeatingDemand: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            heating: boolean;
        }];
    };
    remoteSensing: OptionalWritableAttribute<TypeFromPartialBitSchema<{
        localTemperature: BitFlag;
        occupancy: BitFlag;
        outdoorTemperature: BitFlag;
    }>, any>;
    setpointChangeAmount: OptionalAttribute<null | number, any>;
    setpointChangeSource: OptionalAttribute<Thermostat.SetpointChangeSource, any>;
    setpointChangeSourceTimestamp: OptionalAttribute<number, any>;
    startOfWeek: FixedAttribute<Thermostat.StartOfWeek, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            scheduleConfiguration: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    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>;
    thermostatRunningMode: OptionalAttribute<Thermostat.ThermostatRunningMode, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            autoMode: boolean;
        }];
    };
    thermostatRunningState: OptionalAttribute<TypeFromPartialBitSchema<{
        cool: BitFlag;
        coolStage2: BitFlag;
        fan: BitFlag;
        fanStage2: BitFlag;
        fanStage3: BitFlag;
        heat: BitFlag;
        heatStage2: BitFlag;
    }>, any>;
    unoccupiedCoolingSetpoint: WritableAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            cooling: boolean;
            occupancy: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    unoccupiedHeatingSetpoint: WritableAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            heating: boolean;
            occupancy: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    unoccupiedSetback: WritableAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            occupancy: boolean;
            setback: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    unoccupiedSetbackMax: FixedAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            occupancy: boolean;
            setback: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    unoccupiedSetbackMin: FixedAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            occupancy: boolean;
            setback: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
}, GlobalAttributes<{
    autoMode: BitFlag;
    cooling: BitFlag;
    heating: BitFlag;
    localTemperatureNotExposed: BitFlag;
    occupancy: BitFlag;
    scheduleConfiguration: BitFlag;
    setback: BitFlag;
}>>

Type declaration

  • ReadonlyabsMaxCoolSetpointLimit: OptionalFixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            cooling: boolean;
        }];
    }
  • ReadonlyabsMaxHeatSetpointLimit: OptionalFixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            heating: boolean;
        }];
    }
  • ReadonlyabsMinCoolSetpointLimit: OptionalFixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            cooling: boolean;
        }];
    }
  • ReadonlyabsMinHeatSetpointLimit: OptionalFixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            heating: boolean;
        }];
    }
  • ReadonlyacCapacity: OptionalWritableAttribute<number, any>

    Indicates capacity of Mini Split AC in terms of the format defined by the ACCapacityFormat attribute

    MatterSpecification.v13.Cluster § 4.3.9.46

  • ReadonlyacCapacityFormat: OptionalWritableAttribute<BtUh, any>

    Indicates the format for the ACCapacity attribute.

    MatterSpecification.v13.Cluster § 4.3.9.52

  • ReadonlyacCoilTemperature: OptionalAttribute<null | number, any>

    Indicates the temperature of the AC coil, as measured locally or remotely (over the network).

    MatterSpecification.v13.Cluster § 4.3.9.51

  • ReadonlyacCompressorType: OptionalWritableAttribute<Thermostat.AcCompressorType, any>

    Indicates the type of compressor used within the Mini Split AC.

    MatterSpecification.v13.Cluster § 4.3.9.48

  • ReadonlyacErrorCode: OptionalWritableAttribute<TypeFromPartialBitSchema<{
        coilSensorFail: BitFlag;
        compressorFail: BitFlag;
        fanFail: BitFlag;
        outdoorSensorFail: BitFlag;
        roomSensorFail: BitFlag;
    }>, any>

    Indicates the type of errors encountered within the Mini Split AC.

    MatterSpecification.v13.Cluster § 4.3.9.49

  • ReadonlyacLouverPosition: OptionalWritableAttribute<Thermostat.AcLouverPosition, any>

    Indicates the position of Louver on the AC.

    MatterSpecification.v13.Cluster § 4.3.9.50

  • ReadonlyacRefrigerantType: OptionalWritableAttribute<Thermostat.AcRefrigerantType, any>

    Indicates type of refrigerant used within the Mini Split AC.

    MatterSpecification.v13.Cluster § 4.3.9.47

  • ReadonlyacType: OptionalWritableAttribute<Thermostat.AcType, any>

    Indicates the type of Mini Split ACTypeEnum of Mini Split AC is defined depending on how Cooling and Heating condition is achieved by Mini Split AC.

    MatterSpecification.v13.Cluster § 4.3.9.45

  • ReadonlycontrolSequenceOfOperation: WritableAttribute<Thermostat.ControlSequenceOfOperation, any>

    Indicates the overall operating environment of the thermostat, and thus the possible system modes that the thermostat can operate in.

    MatterSpecification.v13.Cluster § 4.3.9.24

  • ReadonlyemergencyHeatDelta: OptionalWritableAttribute<number, any>

    Indicates the delta between the Calculated Local Temperature and the OccupiedHeatingSetpoint or UnoccupiedHeatingSetpoint attributes at which the Thermostat server will operate in emergency heat mode.

    If the difference between the Calculated Local Temperature and OccupiedCoolingSetpoint or UnoccupiedCoolingSetpoint is greater than or equal to the EmergencyHeatDelta and the Thermostat server’s SystemMode attribute is in a heating-related mode, then the Thermostat server shall immediately switch to the SystemMode attribute value that provides the highest stage of heating (e.g., emergency heat) and continue operating in that running state until the OccupiedHeatingSetpoint value is reached. For example:

    • Calculated Local Temperature = 10.0°C

    • OccupiedHeatingSetpoint = 16.0°C

    • EmergencyHeatDelta = 2.0°C

    ⇒ OccupiedHeatingSetpoint - Calculated Local Temperature ≥? EmergencyHeatDelta

    ⇒ 16°C - 10°C ≥? 2°C

    ⇒ TRUE >>> Thermostat server changes its SystemMode to operate in 2nd stage or emergency heat mode

    The purpose of this attribute is to provide Thermostat clients the ability to configure rapid heating when a setpoint is of a specified amount greater than the measured temperature. This allows the heated space to be quickly heated to the desired level set by the user.

    MatterSpecification.v13.Cluster § 4.3.9.44

  • ReadonlylocalTemperature: Attribute<null | number, any>

    Indicates the current Calculated Local Temperature, when available.

    • If the LTNE feature is not supported:

    ◦ If the LocalTemperatureCalibration is invalid or currently unavailable, the attribute shall report
      null.
    
    ◦ If the LocalTemperatureCalibration is valid, the attribute shall report that value.
    

    • Otherwise, if the LTNE feature is supported, there is no feedback externally available for the LocalTemperatureCalibration. In that case, the LocalTemperature attribute shall always report null.

    MatterSpecification.v13.Cluster § 4.3.9.3

  • ReadonlylocalTemperatureCalibration: OptionalWritableAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [];
    }
  • ReadonlymaxCoolSetpointLimit: OptionalWritableAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            cooling: boolean;
        }];
    }
  • ReadonlymaxHeatSetpointLimit: OptionalWritableAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            heating: boolean;
        }];
    }
  • ReadonlyminCoolSetpointLimit: OptionalWritableAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            cooling: boolean;
        }];
    }
  • ReadonlyminHeatSetpointLimit: OptionalWritableAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            heating: boolean;
        }];
    }
  • ReadonlyminSetpointDeadBand: WritableAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            autoMode: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlynumberOfDailyTransitions: FixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            scheduleConfiguration: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlynumberOfWeeklyTransitions: FixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            scheduleConfiguration: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • Readonlyoccupancy: Attribute<TypeFromPartialBitSchema<{
        occupied: BitFlag;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            occupancy: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlyoccupiedCoolingSetpoint: WritableAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            cooling: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlyoccupiedHeatingSetpoint: WritableAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            heating: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlyoccupiedSetback: WritableAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            setback: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlyoccupiedSetbackMax: FixedAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            setback: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlyoccupiedSetbackMin: FixedAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            setback: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlyoutdoorTemperature: OptionalAttribute<null | number, any>

    Indicates the outdoor temperature, as measured locally or remotely (over the network).

    MatterSpecification.v13.Cluster § 4.3.9.4

  • ReadonlypiCoolingDemand: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            cooling: boolean;
        }];
    }
  • ReadonlypiHeatingDemand: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            heating: boolean;
        }];
    }
  • ReadonlyremoteSensing: OptionalWritableAttribute<TypeFromPartialBitSchema<{
        localTemperature: BitFlag;
        occupancy: BitFlag;
        outdoorTemperature: BitFlag;
    }>, any>

    Indicates when the local temperature, outdoor temperature and occupancy are being sensed by remote networked sensors, rather than internal sensors.

    If the LTNE feature is present in the server, the LocalTemperature RemoteSensing bit value shall always report a value of 0.

    If the LocalTemperature RemoteSensing bit is written with a value of 1 when the LTNE feature is present, the write shall fail and the server shall report a CONSTRAINT_ERROR.

    MatterSpecification.v13.Cluster § 4.3.9.23

  • ReadonlysetpointChangeAmount: OptionalAttribute<null | number, any>

    Indicates the delta between the current active OccupiedCoolingSetpoint or OccupiedHeatingSetpoint and the previous active setpoint. This attribute is meant to accompany the SetpointChangeSource attribute; devices implementing SetpointChangeAmount SHOULD also implement SetpointChangeSource.

    The null value indicates that the previous setpoint was unknown.

    MatterSpecification.v13.Cluster § 4.3.9.36

  • ReadonlysetpointChangeSource: OptionalAttribute<Thermostat.SetpointChangeSource, any>

    Indicates the source of the current active OccupiedCoolingSetpoint or OccupiedHeatingSetpoint (i.e., who or what determined the current setpoint).

    This attribute enables service providers to determine whether changes to setpoints were initiated due to occupant comfort, scheduled programming or some other source (e.g., electric utility or other service provider). Because automation services may initiate frequent setpoint changes, this attribute clearly differentiates the source of setpoint changes made at the thermostat.

    MatterSpecification.v13.Cluster § 4.3.9.35

  • ReadonlysetpointChangeSourceTimestamp: OptionalAttribute<number, any>

    Indicates the time in UTC at which the SetpointChangeAmount attribute change was recorded.

    MatterSpecification.v13.Cluster § 4.3.9.37

  • ReadonlystartOfWeek: FixedAttribute<Thermostat.StartOfWeek, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            scheduleConfiguration: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlysystemMode: WritableAttribute<Thermostat.SystemMode, any>

    Indicates the current operating mode of the thermostat. Its value shall be limited by the ControlSequenceOfOperation attribute.

    MatterSpecification.v13.Cluster § 4.3.9.25

  • ReadonlytemperatureSetpointHold: OptionalWritableAttribute<Thermostat.TemperatureSetpointHold, any>

    Indicates the temperature hold status on the thermostat. If hold status is on, the thermostat SHOULD maintain the temperature setpoint for the current mode until a system mode change. If hold status is off, the thermostat SHOULD follow the setpoint transitions specified by its internal scheduling program. If the thermostat supports setpoint hold for a specific duration, it SHOULD also implement the TemperatureSetpointHoldDuration attribute.

    MatterSpecification.v13.Cluster § 4.3.9.31

  • ReadonlytemperatureSetpointHoldDuration: OptionalWritableAttribute<null | number, any>

    Indicates the period in minutes for which a setpoint hold is active. Thermostats that support hold for a specified duration SHOULD implement this attribute. The null value indicates the field is unused. All other values are reserved.

    MatterSpecification.v13.Cluster § 4.3.9.32

  • ReadonlythermostatProgrammingOperationMode: OptionalWritableAttribute<TypeFromPartialBitSchema<{
        autoRecovery: BitFlag;
        economy: BitFlag;
        scheduleActive: BitFlag;
    }>, any>

    Indicates the operational state of the thermostat’s programming. The thermostat shall modify its programming operation when this attribute is modified by a client and update this attribute when its programming operation is modified locally by a user. The thermostat may support more than one active ProgrammingOperationModeBitmap. For example, the thermostat may operate simultaneously in Schedule Programming Mode and Recovery Mode.

    Thermostats which contain a schedule may use this attribute to control how that schedule is used, even if they do not support the ScheduleConfiguration feature.

    When ScheduleActive is not set, the setpoint is altered only by manual up/down changes at the thermostat or remotely, not by internal schedule programming.

    NOTE

    Modifying the ScheduleActive bit does not clear or delete previous weekly schedule programming configurations.

    MatterSpecification.v13.Cluster § 4.3.9.33

  • ReadonlythermostatRunningMode: OptionalAttribute<Thermostat.ThermostatRunningMode, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            autoMode: boolean;
        }];
    }
  • ReadonlythermostatRunningState: OptionalAttribute<TypeFromPartialBitSchema<{
        cool: BitFlag;
        coolStage2: BitFlag;
        fan: BitFlag;
        fanStage2: BitFlag;
        fanStage3: BitFlag;
        heat: BitFlag;
        heatStage2: BitFlag;
    }>, any>

    Indicates the current relay state of the heat, cool, and fan relays. Unimplemented outputs shall be treated as if they were Off.

    MatterSpecification.v13.Cluster § 4.3.9.34

  • ReadonlyunoccupiedCoolingSetpoint: WritableAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            cooling: boolean;
            occupancy: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlyunoccupiedHeatingSetpoint: WritableAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            heating: boolean;
            occupancy: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlyunoccupiedSetback: WritableAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            occupancy: boolean;
            setback: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlyunoccupiedSetbackMax: FixedAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            occupancy: boolean;
            setback: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlyunoccupiedSetbackMin: FixedAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            occupancy: boolean;
            setback: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
base: undefined
commands: {
    clearWeeklySchedule: Command<void, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            scheduleConfiguration: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    getWeeklySchedule: Command<TypeFromFields<{
        daysToReturn: FieldType<TypeFromPartialBitSchema<{
            away: BitFlag;
            friday: BitFlag;
            monday: BitFlag;
            saturday: BitFlag;
            sunday: BitFlag;
            thursday: BitFlag;
            tuesday: BitFlag;
            wednesday: BitFlag;
        }>>;
        modeToReturn: FieldType<TypeFromPartialBitSchema<{
            coolSetpointPresent: BitFlag;
            heatSetpointPresent: BitFlag;
        }>>;
    }>, TypeFromFields<{
        dayOfWeekForSequence: FieldType<TypeFromPartialBitSchema<{
            away: BitFlag;
            friday: BitFlag;
            monday: BitFlag;
            saturday: BitFlag;
            sunday: BitFlag;
            thursday: BitFlag;
            tuesday: BitFlag;
            wednesday: BitFlag;
        }>>;
        modeForSequence: FieldType<TypeFromPartialBitSchema<{
            coolSetpointPresent: BitFlag;
            heatSetpointPresent: BitFlag;
        }>>;
        numberOfTransitionsForSequence: FieldType<number>;
        transitions: FieldType<TypeFromFields<{
            coolSetpoint: FieldType<(...) | (...)>;
            heatSetpoint: FieldType<(...) | (...)>;
            transitionTime: FieldType<number>;
        }>[]>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            scheduleConfiguration: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    setpointRaiseLower: Command<TypeFromFields<{
        amount: FieldType<number>;
        mode: FieldType<Thermostat.SetpointRaiseLowerMode>;
    }>, void, any>;
    setWeeklySchedule: Command<TypeFromFields<{
        dayOfWeekForSequence: FieldType<TypeFromPartialBitSchema<{
            away: BitFlag;
            friday: BitFlag;
            monday: BitFlag;
            saturday: BitFlag;
            sunday: BitFlag;
            thursday: BitFlag;
            tuesday: BitFlag;
            wednesday: BitFlag;
        }>>;
        modeForSequence: FieldType<TypeFromPartialBitSchema<{
            coolSetpointPresent: BitFlag;
            heatSetpointPresent: BitFlag;
        }>>;
        numberOfTransitionsForSequence: FieldType<number>;
        transitions: FieldType<TypeFromFields<{
            coolSetpoint: FieldType<(...) | (...)>;
            heatSetpoint: FieldType<(...) | (...)>;
            transitionTime: FieldType<number>;
        }>[]>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            scheduleConfiguration: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
}

Type declaration

events: {}
extensions: undefined
features: {
    autoMode: BitFlag;
    cooling: BitFlag;
    heating: BitFlag;
    localTemperatureNotExposed: BitFlag;
    occupancy: BitFlag;
    scheduleConfiguration: BitFlag;
    setback: BitFlag;
}

Type declaration

  • ReadonlyautoMode: BitFlag

    AutoMode

    Supports a System Mode of Auto

  • Readonlycooling: BitFlag

    Cooling

    Thermostat is capable of managing a cooling device

  • Readonlyheating: BitFlag

    Heating

    Thermostat is capable of managing a heating device

  • ReadonlylocalTemperatureNotExposed: BitFlag

    LocalTemperatureNotExposed

    This feature indicates that the Calculated Local Temperature used internally is unavailable to report externally, for example due to the temperature control being done by a separate subsystem which does not offer a view into the currently measured temperature, but allows setpoints to be provided.

    MatterSpecification.v13.Cluster § 4.3.4.1

  • Readonlyoccupancy: BitFlag

    Occupancy

    Supports Occupied and Unoccupied setpoints

  • ReadonlyscheduleConfiguration: BitFlag

    ScheduleConfiguration

    Supports remote configuration of a weekly schedule of setpoint transitions

  • Readonlysetback: BitFlag

    Setback

    Supports configurable setback (or span)

id: Branded<513, "ClusterId">
name
revision
supportedFeatures: {}
unknown

Methods

  • Modify elements using ElementModifier.alter.

    Type Parameters

    • const AlterationsT extends Alterations<Of<{
          attributes: {
              absMaxCoolSetpointLimit: OptionalFixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      cooling: boolean;
                  }];
              };
              absMaxHeatSetpointLimit: OptionalFixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      heating: boolean;
                  }];
              };
              absMinCoolSetpointLimit: OptionalFixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      cooling: boolean;
                  }];
              };
              absMinHeatSetpointLimit: OptionalFixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      heating: boolean;
                  }];
              };
              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>;
              localTemperatureCalibration: OptionalWritableAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [];
              };
              maxCoolSetpointLimit: OptionalWritableAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      cooling: boolean;
                  }];
              };
              maxHeatSetpointLimit: OptionalWritableAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      heating: boolean;
                  }];
              };
              minCoolSetpointLimit: OptionalWritableAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      cooling: boolean;
                  }];
              };
              minHeatSetpointLimit: OptionalWritableAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      heating: boolean;
                  }];
              };
              minSetpointDeadBand: WritableAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      autoMode: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              numberOfDailyTransitions: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      scheduleConfiguration: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              numberOfWeeklyTransitions: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      scheduleConfiguration: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              occupancy: Attribute<TypeFromPartialBitSchema<{
                  occupied: BitFlag;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      occupancy: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              occupiedCoolingSetpoint: WritableAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      cooling: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              occupiedHeatingSetpoint: WritableAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      heating: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              occupiedSetback: WritableAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      setback: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              occupiedSetbackMax: FixedAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      setback: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              occupiedSetbackMin: FixedAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      setback: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              outdoorTemperature: OptionalAttribute<null | number, any>;
              piCoolingDemand: OptionalAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      cooling: boolean;
                  }];
              };
              piHeatingDemand: OptionalAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      heating: boolean;
                  }];
              };
              remoteSensing: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                  localTemperature: BitFlag;
                  occupancy: BitFlag;
                  outdoorTemperature: BitFlag;
              }>, any>;
              setpointChangeAmount: OptionalAttribute<null | number, any>;
              setpointChangeSource: OptionalAttribute<Thermostat.SetpointChangeSource, any>;
              setpointChangeSourceTimestamp: OptionalAttribute<number, any>;
              startOfWeek: FixedAttribute<Thermostat.StartOfWeek, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      scheduleConfiguration: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              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>;
              thermostatRunningMode: OptionalAttribute<Thermostat.ThermostatRunningMode, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      autoMode: boolean;
                  }];
              };
              thermostatRunningState: OptionalAttribute<TypeFromPartialBitSchema<{
                  cool: BitFlag;
                  coolStage2: BitFlag;
                  fan: BitFlag;
                  fanStage2: BitFlag;
                  fanStage3: BitFlag;
                  heat: BitFlag;
                  heatStage2: BitFlag;
              }>, any>;
              unoccupiedCoolingSetpoint: WritableAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      cooling: boolean;
                      occupancy: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              unoccupiedHeatingSetpoint: WritableAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      heating: boolean;
                      occupancy: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              unoccupiedSetback: WritableAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      occupancy: boolean;
                      setback: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              unoccupiedSetbackMax: FixedAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      occupancy: boolean;
                      setback: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              unoccupiedSetbackMin: FixedAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      occupancy: boolean;
                      setback: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          commands: {
              clearWeeklySchedule: Command<void, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      scheduleConfiguration: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              getWeeklySchedule: Command<TypeFromFields<{
                  daysToReturn: FieldType<TypeFromPartialBitSchema<{
                      away: ...;
                      friday: ...;
                      monday: ...;
                      saturday: ...;
                      sunday: ...;
                      thursday: ...;
                      tuesday: ...;
                      wednesday: ...;
                  }>>;
                  modeToReturn: FieldType<TypeFromPartialBitSchema<{
                      coolSetpointPresent: ...;
                      heatSetpointPresent: ...;
                  }>>;
              }>, TypeFromFields<{
                  dayOfWeekForSequence: FieldType<TypeFromPartialBitSchema<{
                      away: ...;
                      friday: ...;
                      monday: ...;
                      saturday: ...;
                      sunday: ...;
                      thursday: ...;
                      tuesday: ...;
                      wednesday: ...;
                  }>>;
                  modeForSequence: FieldType<TypeFromPartialBitSchema<{
                      coolSetpointPresent: ...;
                      heatSetpointPresent: ...;
                  }>>;
                  numberOfTransitionsForSequence: FieldType<number>;
                  transitions: FieldType<TypeFromFields<(...)>[]>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      scheduleConfiguration: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              setpointRaiseLower: Command<TypeFromFields<{
                  amount: FieldType<number>;
                  mode: FieldType<Thermostat.SetpointRaiseLowerMode>;
              }>, void, any>;
              setWeeklySchedule: Command<TypeFromFields<{
                  dayOfWeekForSequence: FieldType<TypeFromPartialBitSchema<{
                      away: ...;
                      friday: ...;
                      monday: ...;
                      saturday: ...;
                      sunday: ...;
                      thursday: ...;
                      tuesday: ...;
                      wednesday: ...;
                  }>>;
                  modeForSequence: FieldType<TypeFromPartialBitSchema<{
                      coolSetpointPresent: ...;
                      heatSetpointPresent: ...;
                  }>>;
                  numberOfTransitionsForSequence: FieldType<number>;
                  transitions: FieldType<TypeFromFields<(...)>[]>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      scheduleConfiguration: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          features: {
              autoMode: BitFlag;
              cooling: BitFlag;
              heating: BitFlag;
              localTemperatureNotExposed: BitFlag;
              occupancy: BitFlag;
              scheduleConfiguration: BitFlag;
              setback: BitFlag;
          };
          id: 513;
          name: "Thermostat";
          revision: 6;
      }>>

    Parameters

    Returns WithAlterations<Of<{
        attributes: {
            absMaxCoolSetpointLimit: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    cooling: boolean;
                }];
            };
            absMaxHeatSetpointLimit: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    heating: boolean;
                }];
            };
            absMinCoolSetpointLimit: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    cooling: boolean;
                }];
            };
            absMinHeatSetpointLimit: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    heating: boolean;
                }];
            };
            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>;
            localTemperatureCalibration: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [];
            };
            maxCoolSetpointLimit: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    cooling: boolean;
                }];
            };
            maxHeatSetpointLimit: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    heating: boolean;
                }];
            };
            minCoolSetpointLimit: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    cooling: boolean;
                }];
            };
            minHeatSetpointLimit: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    heating: boolean;
                }];
            };
            minSetpointDeadBand: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    autoMode: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfDailyTransitions: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    scheduleConfiguration: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfWeeklyTransitions: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    scheduleConfiguration: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            occupancy: Attribute<TypeFromPartialBitSchema<{
                occupied: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    occupancy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            occupiedCoolingSetpoint: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    cooling: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            occupiedHeatingSetpoint: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    heating: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            occupiedSetback: WritableAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    setback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            occupiedSetbackMax: FixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    setback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            occupiedSetbackMin: FixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    setback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            outdoorTemperature: OptionalAttribute<null | number, any>;
            piCoolingDemand: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    cooling: boolean;
                }];
            };
            piHeatingDemand: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    heating: boolean;
                }];
            };
            remoteSensing: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                localTemperature: BitFlag;
                occupancy: BitFlag;
                outdoorTemperature: BitFlag;
            }>, any>;
            setpointChangeAmount: OptionalAttribute<null | number, any>;
            setpointChangeSource: OptionalAttribute<Thermostat.SetpointChangeSource, any>;
            setpointChangeSourceTimestamp: OptionalAttribute<number, any>;
            startOfWeek: FixedAttribute<Thermostat.StartOfWeek, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    scheduleConfiguration: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            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>;
            thermostatRunningMode: OptionalAttribute<Thermostat.ThermostatRunningMode, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    autoMode: boolean;
                }];
            };
            thermostatRunningState: OptionalAttribute<TypeFromPartialBitSchema<{
                cool: BitFlag;
                coolStage2: BitFlag;
                fan: BitFlag;
                fanStage2: BitFlag;
                fanStage3: BitFlag;
                heat: BitFlag;
                heatStage2: BitFlag;
            }>, any>;
            unoccupiedCoolingSetpoint: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    cooling: boolean;
                    occupancy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unoccupiedHeatingSetpoint: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    heating: boolean;
                    occupancy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unoccupiedSetback: WritableAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    occupancy: boolean;
                    setback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unoccupiedSetbackMax: FixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    occupancy: boolean;
                    setback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unoccupiedSetbackMin: FixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    occupancy: boolean;
                    setback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            clearWeeklySchedule: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    scheduleConfiguration: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getWeeklySchedule: Command<TypeFromFields<{
                daysToReturn: FieldType<TypeFromPartialBitSchema<{
                    away: ...;
                    friday: ...;
                    monday: ...;
                    saturday: ...;
                    sunday: ...;
                    thursday: ...;
                    tuesday: ...;
                    wednesday: ...;
                }>>;
                modeToReturn: FieldType<TypeFromPartialBitSchema<{
                    coolSetpointPresent: ...;
                    heatSetpointPresent: ...;
                }>>;
            }>, TypeFromFields<{
                dayOfWeekForSequence: FieldType<TypeFromPartialBitSchema<{
                    away: ...;
                    friday: ...;
                    monday: ...;
                    saturday: ...;
                    sunday: ...;
                    thursday: ...;
                    tuesday: ...;
                    wednesday: ...;
                }>>;
                modeForSequence: FieldType<TypeFromPartialBitSchema<{
                    coolSetpointPresent: ...;
                    heatSetpointPresent: ...;
                }>>;
                numberOfTransitionsForSequence: FieldType<number>;
                transitions: FieldType<TypeFromFields<(...)>[]>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    scheduleConfiguration: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setpointRaiseLower: Command<TypeFromFields<{
                amount: FieldType<number>;
                mode: FieldType<Thermostat.SetpointRaiseLowerMode>;
            }>, void, any>;
            setWeeklySchedule: Command<TypeFromFields<{
                dayOfWeekForSequence: FieldType<TypeFromPartialBitSchema<{
                    away: ...;
                    friday: ...;
                    monday: ...;
                    saturday: ...;
                    sunday: ...;
                    thursday: ...;
                    tuesday: ...;
                    wednesday: ...;
                }>>;
                modeForSequence: FieldType<TypeFromPartialBitSchema<{
                    coolSetpointPresent: ...;
                    heatSetpointPresent: ...;
                }>>;
                numberOfTransitionsForSequence: FieldType<number>;
                transitions: FieldType<TypeFromFields<(...)>[]>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    scheduleConfiguration: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            autoMode: BitFlag;
            cooling: BitFlag;
            heating: BitFlag;
            localTemperatureNotExposed: BitFlag;
            occupancy: BitFlag;
            scheduleConfiguration: BitFlag;
            setback: BitFlag;
        };
        id: 513;
        name: "Thermostat";
        revision: 6;
    }>, AlterationsT>

  • Modify elements using ElementModifier.enable.

    Type Parameters

    • const FlagsT extends ElementFlags<Of<{
          attributes: {
              absMaxCoolSetpointLimit: OptionalFixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      cooling: boolean;
                  }];
              };
              absMaxHeatSetpointLimit: OptionalFixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      heating: boolean;
                  }];
              };
              absMinCoolSetpointLimit: OptionalFixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      cooling: boolean;
                  }];
              };
              absMinHeatSetpointLimit: OptionalFixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      heating: boolean;
                  }];
              };
              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>;
              localTemperatureCalibration: OptionalWritableAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [];
              };
              maxCoolSetpointLimit: OptionalWritableAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      cooling: boolean;
                  }];
              };
              maxHeatSetpointLimit: OptionalWritableAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      heating: boolean;
                  }];
              };
              minCoolSetpointLimit: OptionalWritableAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      cooling: boolean;
                  }];
              };
              minHeatSetpointLimit: OptionalWritableAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      heating: boolean;
                  }];
              };
              minSetpointDeadBand: WritableAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      autoMode: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              numberOfDailyTransitions: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      scheduleConfiguration: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              numberOfWeeklyTransitions: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      scheduleConfiguration: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              occupancy: Attribute<TypeFromPartialBitSchema<{
                  occupied: BitFlag;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      occupancy: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              occupiedCoolingSetpoint: WritableAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      cooling: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              occupiedHeatingSetpoint: WritableAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      heating: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              occupiedSetback: WritableAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      setback: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              occupiedSetbackMax: FixedAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      setback: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              occupiedSetbackMin: FixedAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      setback: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              outdoorTemperature: OptionalAttribute<null | number, any>;
              piCoolingDemand: OptionalAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      cooling: boolean;
                  }];
              };
              piHeatingDemand: OptionalAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      heating: boolean;
                  }];
              };
              remoteSensing: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                  localTemperature: BitFlag;
                  occupancy: BitFlag;
                  outdoorTemperature: BitFlag;
              }>, any>;
              setpointChangeAmount: OptionalAttribute<null | number, any>;
              setpointChangeSource: OptionalAttribute<Thermostat.SetpointChangeSource, any>;
              setpointChangeSourceTimestamp: OptionalAttribute<number, any>;
              startOfWeek: FixedAttribute<Thermostat.StartOfWeek, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      scheduleConfiguration: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              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>;
              thermostatRunningMode: OptionalAttribute<Thermostat.ThermostatRunningMode, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      autoMode: boolean;
                  }];
              };
              thermostatRunningState: OptionalAttribute<TypeFromPartialBitSchema<{
                  cool: BitFlag;
                  coolStage2: BitFlag;
                  fan: BitFlag;
                  fanStage2: BitFlag;
                  fanStage3: BitFlag;
                  heat: BitFlag;
                  heatStage2: BitFlag;
              }>, any>;
              unoccupiedCoolingSetpoint: WritableAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      cooling: boolean;
                      occupancy: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              unoccupiedHeatingSetpoint: WritableAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      heating: boolean;
                      occupancy: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              unoccupiedSetback: WritableAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      occupancy: boolean;
                      setback: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              unoccupiedSetbackMax: FixedAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      occupancy: boolean;
                      setback: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              unoccupiedSetbackMin: FixedAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      occupancy: boolean;
                      setback: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          commands: {
              clearWeeklySchedule: Command<void, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      scheduleConfiguration: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              getWeeklySchedule: Command<TypeFromFields<{
                  daysToReturn: FieldType<TypeFromPartialBitSchema<{
                      away: ...;
                      friday: ...;
                      monday: ...;
                      saturday: ...;
                      sunday: ...;
                      thursday: ...;
                      tuesday: ...;
                      wednesday: ...;
                  }>>;
                  modeToReturn: FieldType<TypeFromPartialBitSchema<{
                      coolSetpointPresent: ...;
                      heatSetpointPresent: ...;
                  }>>;
              }>, TypeFromFields<{
                  dayOfWeekForSequence: FieldType<TypeFromPartialBitSchema<{
                      away: ...;
                      friday: ...;
                      monday: ...;
                      saturday: ...;
                      sunday: ...;
                      thursday: ...;
                      tuesday: ...;
                      wednesday: ...;
                  }>>;
                  modeForSequence: FieldType<TypeFromPartialBitSchema<{
                      coolSetpointPresent: ...;
                      heatSetpointPresent: ...;
                  }>>;
                  numberOfTransitionsForSequence: FieldType<number>;
                  transitions: FieldType<TypeFromFields<(...)>[]>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      scheduleConfiguration: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              setpointRaiseLower: Command<TypeFromFields<{
                  amount: FieldType<number>;
                  mode: FieldType<Thermostat.SetpointRaiseLowerMode>;
              }>, void, any>;
              setWeeklySchedule: Command<TypeFromFields<{
                  dayOfWeekForSequence: FieldType<TypeFromPartialBitSchema<{
                      away: ...;
                      friday: ...;
                      monday: ...;
                      saturday: ...;
                      sunday: ...;
                      thursday: ...;
                      tuesday: ...;
                      wednesday: ...;
                  }>>;
                  modeForSequence: FieldType<TypeFromPartialBitSchema<{
                      coolSetpointPresent: ...;
                      heatSetpointPresent: ...;
                  }>>;
                  numberOfTransitionsForSequence: FieldType<number>;
                  transitions: FieldType<TypeFromFields<(...)>[]>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      scheduleConfiguration: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          features: {
              autoMode: BitFlag;
              cooling: BitFlag;
              heating: BitFlag;
              localTemperatureNotExposed: BitFlag;
              occupancy: BitFlag;
              scheduleConfiguration: BitFlag;
              setback: BitFlag;
          };
          id: 513;
          name: "Thermostat";
          revision: 6;
      }>>

    Parameters

    Returns WithFlags<Of<{
        attributes: {
            absMaxCoolSetpointLimit: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    cooling: boolean;
                }];
            };
            absMaxHeatSetpointLimit: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    heating: boolean;
                }];
            };
            absMinCoolSetpointLimit: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    cooling: boolean;
                }];
            };
            absMinHeatSetpointLimit: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    heating: boolean;
                }];
            };
            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>;
            localTemperatureCalibration: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [];
            };
            maxCoolSetpointLimit: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    cooling: boolean;
                }];
            };
            maxHeatSetpointLimit: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    heating: boolean;
                }];
            };
            minCoolSetpointLimit: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    cooling: boolean;
                }];
            };
            minHeatSetpointLimit: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    heating: boolean;
                }];
            };
            minSetpointDeadBand: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    autoMode: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfDailyTransitions: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    scheduleConfiguration: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfWeeklyTransitions: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    scheduleConfiguration: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            occupancy: Attribute<TypeFromPartialBitSchema<{
                occupied: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    occupancy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            occupiedCoolingSetpoint: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    cooling: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            occupiedHeatingSetpoint: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    heating: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            occupiedSetback: WritableAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    setback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            occupiedSetbackMax: FixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    setback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            occupiedSetbackMin: FixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    setback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            outdoorTemperature: OptionalAttribute<null | number, any>;
            piCoolingDemand: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    cooling: boolean;
                }];
            };
            piHeatingDemand: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    heating: boolean;
                }];
            };
            remoteSensing: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                localTemperature: BitFlag;
                occupancy: BitFlag;
                outdoorTemperature: BitFlag;
            }>, any>;
            setpointChangeAmount: OptionalAttribute<null | number, any>;
            setpointChangeSource: OptionalAttribute<Thermostat.SetpointChangeSource, any>;
            setpointChangeSourceTimestamp: OptionalAttribute<number, any>;
            startOfWeek: FixedAttribute<Thermostat.StartOfWeek, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    scheduleConfiguration: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            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>;
            thermostatRunningMode: OptionalAttribute<Thermostat.ThermostatRunningMode, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    autoMode: boolean;
                }];
            };
            thermostatRunningState: OptionalAttribute<TypeFromPartialBitSchema<{
                cool: BitFlag;
                coolStage2: BitFlag;
                fan: BitFlag;
                fanStage2: BitFlag;
                fanStage3: BitFlag;
                heat: BitFlag;
                heatStage2: BitFlag;
            }>, any>;
            unoccupiedCoolingSetpoint: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    cooling: boolean;
                    occupancy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unoccupiedHeatingSetpoint: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    heating: boolean;
                    occupancy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unoccupiedSetback: WritableAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    occupancy: boolean;
                    setback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unoccupiedSetbackMax: FixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    occupancy: boolean;
                    setback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unoccupiedSetbackMin: FixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    occupancy: boolean;
                    setback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            clearWeeklySchedule: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    scheduleConfiguration: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getWeeklySchedule: Command<TypeFromFields<{
                daysToReturn: FieldType<TypeFromPartialBitSchema<{
                    away: ...;
                    friday: ...;
                    monday: ...;
                    saturday: ...;
                    sunday: ...;
                    thursday: ...;
                    tuesday: ...;
                    wednesday: ...;
                }>>;
                modeToReturn: FieldType<TypeFromPartialBitSchema<{
                    coolSetpointPresent: ...;
                    heatSetpointPresent: ...;
                }>>;
            }>, TypeFromFields<{
                dayOfWeekForSequence: FieldType<TypeFromPartialBitSchema<{
                    away: ...;
                    friday: ...;
                    monday: ...;
                    saturday: ...;
                    sunday: ...;
                    thursday: ...;
                    tuesday: ...;
                    wednesday: ...;
                }>>;
                modeForSequence: FieldType<TypeFromPartialBitSchema<{
                    coolSetpointPresent: ...;
                    heatSetpointPresent: ...;
                }>>;
                numberOfTransitionsForSequence: FieldType<number>;
                transitions: FieldType<TypeFromFields<(...)>[]>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    scheduleConfiguration: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setpointRaiseLower: Command<TypeFromFields<{
                amount: FieldType<number>;
                mode: FieldType<Thermostat.SetpointRaiseLowerMode>;
            }>, void, any>;
            setWeeklySchedule: Command<TypeFromFields<{
                dayOfWeekForSequence: FieldType<TypeFromPartialBitSchema<{
                    away: ...;
                    friday: ...;
                    monday: ...;
                    saturday: ...;
                    sunday: ...;
                    thursday: ...;
                    tuesday: ...;
                    wednesday: ...;
                }>>;
                modeForSequence: FieldType<TypeFromPartialBitSchema<{
                    coolSetpointPresent: ...;
                    heatSetpointPresent: ...;
                }>>;
                numberOfTransitionsForSequence: FieldType<number>;
                transitions: FieldType<TypeFromFields<(...)>[]>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    scheduleConfiguration: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            autoMode: BitFlag;
            cooling: BitFlag;
            heating: BitFlag;
            localTemperatureNotExposed: BitFlag;
            occupancy: BitFlag;
            scheduleConfiguration: BitFlag;
            setback: BitFlag;
        };
        id: 513;
        name: "Thermostat";
        revision: 6;
    }>, FlagsT>

  • Modify elements using ElementModifier.set.

    Type Parameters

    • const ValuesT extends {
          absMaxCoolSetpointLimit?: number;
          absMaxHeatSetpointLimit?: number;
          absMinCoolSetpointLimit?: number;
          absMinHeatSetpointLimit?: number;
          acCapacity?: number;
          acCapacityFormat?: number;
          acCoilTemperature?: null | number;
          acCompressorType?: number;
          acErrorCode?: {
              coilSensorFail?: boolean;
              compressorFail?: boolean;
              fanFail?: boolean;
              outdoorSensorFail?: boolean;
              roomSensorFail?: boolean;
          };
          acLouverPosition?: number;
          acRefrigerantType?: number;
          acType?: number;
          controlSequenceOfOperation: number;
          emergencyHeatDelta?: number;
          localTemperature: null | number;
          localTemperatureCalibration?: number;
          maxCoolSetpointLimit?: number;
          maxHeatSetpointLimit?: number;
          minCoolSetpointLimit?: number;
          minHeatSetpointLimit?: number;
          minSetpointDeadBand?: number;
          numberOfDailyTransitions?: number;
          numberOfWeeklyTransitions?: number;
          occupancy?: {
              occupied?: boolean;
          };
          occupiedCoolingSetpoint?: number;
          occupiedHeatingSetpoint?: number;
          occupiedSetback?: null | number;
          occupiedSetbackMax?: null | number;
          occupiedSetbackMin?: null | number;
          outdoorTemperature?: null | number;
          piCoolingDemand?: number;
          piHeatingDemand?: number;
          remoteSensing?: {
              localTemperature?: boolean;
              occupancy?: boolean;
              outdoorTemperature?: boolean;
          };
          setpointChangeAmount?: null | number;
          setpointChangeSource?: number;
          setpointChangeSourceTimestamp?: number;
          startOfWeek?: number;
          systemMode: number;
          temperatureSetpointHold?: number;
          temperatureSetpointHoldDuration?: null | number;
          thermostatProgrammingOperationMode?: {
              autoRecovery?: boolean;
              economy?: boolean;
              scheduleActive?: boolean;
          };
          thermostatRunningMode?: number;
          thermostatRunningState?: {
              cool?: boolean;
              coolStage2?: boolean;
              fan?: boolean;
              fanStage2?: boolean;
              fanStage3?: boolean;
              heat?: boolean;
              heatStage2?: boolean;
          };
          unoccupiedCoolingSetpoint?: number;
          unoccupiedHeatingSetpoint?: number;
          unoccupiedSetback?: null | number;
          unoccupiedSetbackMax?: null | number;
          unoccupiedSetbackMin?: null | number;
      }

    Parameters

    Returns WithValues<Of<{
        attributes: {
            absMaxCoolSetpointLimit: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    cooling: boolean;
                }];
            };
            absMaxHeatSetpointLimit: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    heating: boolean;
                }];
            };
            absMinCoolSetpointLimit: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    cooling: boolean;
                }];
            };
            absMinHeatSetpointLimit: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    heating: boolean;
                }];
            };
            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>;
            localTemperatureCalibration: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [];
            };
            maxCoolSetpointLimit: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    cooling: boolean;
                }];
            };
            maxHeatSetpointLimit: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    heating: boolean;
                }];
            };
            minCoolSetpointLimit: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    cooling: boolean;
                }];
            };
            minHeatSetpointLimit: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    heating: boolean;
                }];
            };
            minSetpointDeadBand: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    autoMode: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfDailyTransitions: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    scheduleConfiguration: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfWeeklyTransitions: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    scheduleConfiguration: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            occupancy: Attribute<TypeFromPartialBitSchema<{
                occupied: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    occupancy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            occupiedCoolingSetpoint: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    cooling: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            occupiedHeatingSetpoint: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    heating: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            occupiedSetback: WritableAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    setback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            occupiedSetbackMax: FixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    setback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            occupiedSetbackMin: FixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    setback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            outdoorTemperature: OptionalAttribute<null | number, any>;
            piCoolingDemand: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    cooling: boolean;
                }];
            };
            piHeatingDemand: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    heating: boolean;
                }];
            };
            remoteSensing: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                localTemperature: BitFlag;
                occupancy: BitFlag;
                outdoorTemperature: BitFlag;
            }>, any>;
            setpointChangeAmount: OptionalAttribute<null | number, any>;
            setpointChangeSource: OptionalAttribute<Thermostat.SetpointChangeSource, any>;
            setpointChangeSourceTimestamp: OptionalAttribute<number, any>;
            startOfWeek: FixedAttribute<Thermostat.StartOfWeek, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    scheduleConfiguration: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            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>;
            thermostatRunningMode: OptionalAttribute<Thermostat.ThermostatRunningMode, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    autoMode: boolean;
                }];
            };
            thermostatRunningState: OptionalAttribute<TypeFromPartialBitSchema<{
                cool: BitFlag;
                coolStage2: BitFlag;
                fan: BitFlag;
                fanStage2: BitFlag;
                fanStage3: BitFlag;
                heat: BitFlag;
                heatStage2: BitFlag;
            }>, any>;
            unoccupiedCoolingSetpoint: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    cooling: boolean;
                    occupancy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unoccupiedHeatingSetpoint: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    heating: boolean;
                    occupancy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unoccupiedSetback: WritableAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    occupancy: boolean;
                    setback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unoccupiedSetbackMax: FixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    occupancy: boolean;
                    setback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unoccupiedSetbackMin: FixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    occupancy: boolean;
                    setback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            clearWeeklySchedule: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    scheduleConfiguration: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getWeeklySchedule: Command<TypeFromFields<{
                daysToReturn: FieldType<TypeFromPartialBitSchema<{
                    away: ...;
                    friday: ...;
                    monday: ...;
                    saturday: ...;
                    sunday: ...;
                    thursday: ...;
                    tuesday: ...;
                    wednesday: ...;
                }>>;
                modeToReturn: FieldType<TypeFromPartialBitSchema<{
                    coolSetpointPresent: ...;
                    heatSetpointPresent: ...;
                }>>;
            }>, TypeFromFields<{
                dayOfWeekForSequence: FieldType<TypeFromPartialBitSchema<{
                    away: ...;
                    friday: ...;
                    monday: ...;
                    saturday: ...;
                    sunday: ...;
                    thursday: ...;
                    tuesday: ...;
                    wednesday: ...;
                }>>;
                modeForSequence: FieldType<TypeFromPartialBitSchema<{
                    coolSetpointPresent: ...;
                    heatSetpointPresent: ...;
                }>>;
                numberOfTransitionsForSequence: FieldType<number>;
                transitions: FieldType<TypeFromFields<(...)>[]>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    scheduleConfiguration: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setpointRaiseLower: Command<TypeFromFields<{
                amount: FieldType<number>;
                mode: FieldType<Thermostat.SetpointRaiseLowerMode>;
            }>, void, any>;
            setWeeklySchedule: Command<TypeFromFields<{
                dayOfWeekForSequence: FieldType<TypeFromPartialBitSchema<{
                    away: ...;
                    friday: ...;
                    monday: ...;
                    saturday: ...;
                    sunday: ...;
                    thursday: ...;
                    tuesday: ...;
                    wednesday: ...;
                }>>;
                modeForSequence: FieldType<TypeFromPartialBitSchema<{
                    coolSetpointPresent: ...;
                    heatSetpointPresent: ...;
                }>>;
                numberOfTransitionsForSequence: FieldType<number>;
                transitions: FieldType<TypeFromFields<(...)>[]>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    scheduleConfiguration: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            autoMode: BitFlag;
            cooling: BitFlag;
            heating: BitFlag;
            localTemperatureNotExposed: BitFlag;
            occupancy: BitFlag;
            scheduleConfiguration: BitFlag;
            setback: BitFlag;
        };
        id: 513;
        name: "Thermostat";
        revision: 6;
    }>, ValuesT>

  • Select features using ClusterComposer.compose.

    Type Parameters

    • const SelectionT extends FeatureSelection<Of<{
          attributes: {
              absMaxCoolSetpointLimit: OptionalFixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      cooling: boolean;
                  }];
              };
              absMaxHeatSetpointLimit: OptionalFixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      heating: boolean;
                  }];
              };
              absMinCoolSetpointLimit: OptionalFixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      cooling: boolean;
                  }];
              };
              absMinHeatSetpointLimit: OptionalFixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      heating: boolean;
                  }];
              };
              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>;
              localTemperatureCalibration: OptionalWritableAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [];
              };
              maxCoolSetpointLimit: OptionalWritableAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      cooling: boolean;
                  }];
              };
              maxHeatSetpointLimit: OptionalWritableAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      heating: boolean;
                  }];
              };
              minCoolSetpointLimit: OptionalWritableAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      cooling: boolean;
                  }];
              };
              minHeatSetpointLimit: OptionalWritableAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      heating: boolean;
                  }];
              };
              minSetpointDeadBand: WritableAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      autoMode: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              numberOfDailyTransitions: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      scheduleConfiguration: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              numberOfWeeklyTransitions: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      scheduleConfiguration: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              occupancy: Attribute<TypeFromPartialBitSchema<{
                  occupied: BitFlag;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      occupancy: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              occupiedCoolingSetpoint: WritableAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      cooling: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              occupiedHeatingSetpoint: WritableAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      heating: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              occupiedSetback: WritableAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      setback: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              occupiedSetbackMax: FixedAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      setback: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              occupiedSetbackMin: FixedAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      setback: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              outdoorTemperature: OptionalAttribute<null | number, any>;
              piCoolingDemand: OptionalAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      cooling: boolean;
                  }];
              };
              piHeatingDemand: OptionalAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      heating: boolean;
                  }];
              };
              remoteSensing: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                  localTemperature: BitFlag;
                  occupancy: BitFlag;
                  outdoorTemperature: BitFlag;
              }>, any>;
              setpointChangeAmount: OptionalAttribute<null | number, any>;
              setpointChangeSource: OptionalAttribute<Thermostat.SetpointChangeSource, any>;
              setpointChangeSourceTimestamp: OptionalAttribute<number, any>;
              startOfWeek: FixedAttribute<Thermostat.StartOfWeek, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      scheduleConfiguration: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              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>;
              thermostatRunningMode: OptionalAttribute<Thermostat.ThermostatRunningMode, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      autoMode: boolean;
                  }];
              };
              thermostatRunningState: OptionalAttribute<TypeFromPartialBitSchema<{
                  cool: BitFlag;
                  coolStage2: BitFlag;
                  fan: BitFlag;
                  fanStage2: BitFlag;
                  fanStage3: BitFlag;
                  heat: BitFlag;
                  heatStage2: BitFlag;
              }>, any>;
              unoccupiedCoolingSetpoint: WritableAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      cooling: boolean;
                      occupancy: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              unoccupiedHeatingSetpoint: WritableAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      heating: boolean;
                      occupancy: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              unoccupiedSetback: WritableAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      occupancy: boolean;
                      setback: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              unoccupiedSetbackMax: FixedAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      occupancy: boolean;
                      setback: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              unoccupiedSetbackMin: FixedAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      occupancy: boolean;
                      setback: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          commands: {
              clearWeeklySchedule: Command<void, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      scheduleConfiguration: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              getWeeklySchedule: Command<TypeFromFields<{
                  daysToReturn: FieldType<TypeFromPartialBitSchema<{
                      away: ...;
                      friday: ...;
                      monday: ...;
                      saturday: ...;
                      sunday: ...;
                      thursday: ...;
                      tuesday: ...;
                      wednesday: ...;
                  }>>;
                  modeToReturn: FieldType<TypeFromPartialBitSchema<{
                      coolSetpointPresent: ...;
                      heatSetpointPresent: ...;
                  }>>;
              }>, TypeFromFields<{
                  dayOfWeekForSequence: FieldType<TypeFromPartialBitSchema<{
                      away: ...;
                      friday: ...;
                      monday: ...;
                      saturday: ...;
                      sunday: ...;
                      thursday: ...;
                      tuesday: ...;
                      wednesday: ...;
                  }>>;
                  modeForSequence: FieldType<TypeFromPartialBitSchema<{
                      coolSetpointPresent: ...;
                      heatSetpointPresent: ...;
                  }>>;
                  numberOfTransitionsForSequence: FieldType<number>;
                  transitions: FieldType<TypeFromFields<(...)>[]>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      scheduleConfiguration: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              setpointRaiseLower: Command<TypeFromFields<{
                  amount: FieldType<number>;
                  mode: FieldType<Thermostat.SetpointRaiseLowerMode>;
              }>, void, any>;
              setWeeklySchedule: Command<TypeFromFields<{
                  dayOfWeekForSequence: FieldType<TypeFromPartialBitSchema<{
                      away: ...;
                      friday: ...;
                      monday: ...;
                      saturday: ...;
                      sunday: ...;
                      thursday: ...;
                      tuesday: ...;
                      wednesday: ...;
                  }>>;
                  modeForSequence: FieldType<TypeFromPartialBitSchema<{
                      coolSetpointPresent: ...;
                      heatSetpointPresent: ...;
                  }>>;
                  numberOfTransitionsForSequence: FieldType<number>;
                  transitions: FieldType<TypeFromFields<(...)>[]>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      scheduleConfiguration: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          features: {
              autoMode: BitFlag;
              cooling: BitFlag;
              heating: BitFlag;
              localTemperatureNotExposed: BitFlag;
              occupancy: BitFlag;
              scheduleConfiguration: BitFlag;
              setback: BitFlag;
          };
          id: 513;
          name: "Thermostat";
          revision: 6;
      }>>

    Parameters

    Returns Of<Of<{
        attributes: {
            absMaxCoolSetpointLimit: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    cooling: boolean;
                }];
            };
            absMaxHeatSetpointLimit: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    heating: boolean;
                }];
            };
            absMinCoolSetpointLimit: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    cooling: boolean;
                }];
            };
            absMinHeatSetpointLimit: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    heating: boolean;
                }];
            };
            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>;
            localTemperatureCalibration: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [];
            };
            maxCoolSetpointLimit: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    cooling: boolean;
                }];
            };
            maxHeatSetpointLimit: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    heating: boolean;
                }];
            };
            minCoolSetpointLimit: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    cooling: boolean;
                }];
            };
            minHeatSetpointLimit: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    heating: boolean;
                }];
            };
            minSetpointDeadBand: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    autoMode: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfDailyTransitions: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    scheduleConfiguration: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfWeeklyTransitions: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    scheduleConfiguration: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            occupancy: Attribute<TypeFromPartialBitSchema<{
                occupied: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    occupancy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            occupiedCoolingSetpoint: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    cooling: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            occupiedHeatingSetpoint: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    heating: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            occupiedSetback: WritableAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    setback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            occupiedSetbackMax: FixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    setback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            occupiedSetbackMin: FixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    setback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            outdoorTemperature: OptionalAttribute<null | number, any>;
            piCoolingDemand: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    cooling: boolean;
                }];
            };
            piHeatingDemand: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    heating: boolean;
                }];
            };
            remoteSensing: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                localTemperature: BitFlag;
                occupancy: BitFlag;
                outdoorTemperature: BitFlag;
            }>, any>;
            setpointChangeAmount: OptionalAttribute<null | number, any>;
            setpointChangeSource: OptionalAttribute<Thermostat.SetpointChangeSource, any>;
            setpointChangeSourceTimestamp: OptionalAttribute<number, any>;
            startOfWeek: FixedAttribute<Thermostat.StartOfWeek, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    scheduleConfiguration: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            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>;
            thermostatRunningMode: OptionalAttribute<Thermostat.ThermostatRunningMode, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    autoMode: boolean;
                }];
            };
            thermostatRunningState: OptionalAttribute<TypeFromPartialBitSchema<{
                cool: BitFlag;
                coolStage2: BitFlag;
                fan: BitFlag;
                fanStage2: BitFlag;
                fanStage3: BitFlag;
                heat: BitFlag;
                heatStage2: BitFlag;
            }>, any>;
            unoccupiedCoolingSetpoint: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    cooling: boolean;
                    occupancy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unoccupiedHeatingSetpoint: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    heating: boolean;
                    occupancy: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unoccupiedSetback: WritableAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    occupancy: boolean;
                    setback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unoccupiedSetbackMax: FixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    occupancy: boolean;
                    setback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unoccupiedSetbackMin: FixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    occupancy: boolean;
                    setback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            clearWeeklySchedule: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    scheduleConfiguration: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getWeeklySchedule: Command<TypeFromFields<{
                daysToReturn: FieldType<TypeFromPartialBitSchema<{
                    away: ...;
                    friday: ...;
                    monday: ...;
                    saturday: ...;
                    sunday: ...;
                    thursday: ...;
                    tuesday: ...;
                    wednesday: ...;
                }>>;
                modeToReturn: FieldType<TypeFromPartialBitSchema<{
                    coolSetpointPresent: ...;
                    heatSetpointPresent: ...;
                }>>;
            }>, TypeFromFields<{
                dayOfWeekForSequence: FieldType<TypeFromPartialBitSchema<{
                    away: ...;
                    friday: ...;
                    monday: ...;
                    saturday: ...;
                    sunday: ...;
                    thursday: ...;
                    tuesday: ...;
                    wednesday: ...;
                }>>;
                modeForSequence: FieldType<TypeFromPartialBitSchema<{
                    coolSetpointPresent: ...;
                    heatSetpointPresent: ...;
                }>>;
                numberOfTransitionsForSequence: FieldType<number>;
                transitions: FieldType<TypeFromFields<(...)>[]>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    scheduleConfiguration: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setpointRaiseLower: Command<TypeFromFields<{
                amount: FieldType<number>;
                mode: FieldType<Thermostat.SetpointRaiseLowerMode>;
            }>, void, any>;
            setWeeklySchedule: Command<TypeFromFields<{
                dayOfWeekForSequence: FieldType<TypeFromPartialBitSchema<{
                    away: ...;
                    friday: ...;
                    monday: ...;
                    saturday: ...;
                    sunday: ...;
                    thursday: ...;
                    tuesday: ...;
                    wednesday: ...;
                }>>;
                modeForSequence: FieldType<TypeFromPartialBitSchema<{
                    coolSetpointPresent: ...;
                    heatSetpointPresent: ...;
                }>>;
                numberOfTransitionsForSequence: FieldType<number>;
                transitions: FieldType<TypeFromFields<(...)>[]>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    scheduleConfiguration: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            autoMode: BitFlag;
            cooling: BitFlag;
            heating: BitFlag;
            localTemperatureNotExposed: BitFlag;
            occupancy: BitFlag;
            scheduleConfiguration: BitFlag;
            setback: BitFlag;
        };
        id: 513;
        name: "Thermostat";
        revision: 6;
    }>, SelectionT>