Class ThermostatServer

This is the default server implementation of ThermostatBehavior.

The Matter specification requires the Thermostat cluster to support features we do not enable by default. You should use ThermostatServer.with to specialize the class for the features your implementation supports.

Hierarchy (view full)

Constructors

constructor

Properties

[reference] agent cluster context endpoint env events features session state cluster defaults dependencies? early Events ExtensionInterface id Interface Internal name schema? State supervisor supports

Methods

[asyncDispose] asAdmin assertAttributeEnabled callback initialize reactTo requireAttributeEnabled setpointRaiseLower toString alter enable for set with

Constructors

constructor

  • new ThermostatServer(agent, backing): ThermostatServer

  • Parameters

    • agent: Agent
    • backing: BehaviorBacking

    Returns ThermostatServer

Properties

[reference]

[reference]: Datasource<StateType>

agent

agent: Agent

cluster

cluster: never

The implemented cluster.

context

context: ActionContext

endpoint

endpoint: Endpoint<Empty>

env

env: Environment

Readonlyevents

events: EventEmitter & Omit<ClusterEvents<Of<{
    attributes: {};
    commands: {};
    events: {};
    id: 0;
    name: "Unknown";
    revision: 0;
}>, typeof ClusterBehavior>, never> & {
    controlSequenceOfOperation$Changing: ClusterEvents.AttributeObservable<WritableAttribute<Thermostat.ControlSequenceOfOperation, any>>;
    localTemperature$Changing: ClusterEvents.AttributeObservable<Attribute<null | number, any>>;
    systemMode$Changing: ClusterEvents.AttributeObservable<WritableAttribute<Thermostat.SystemMode, any>>;
} & {
    acCapacity$Changing: undefined | ClusterEvents.AttributeObservable<OptionalWritableAttribute<number, any>>;
    acCapacityFormat$Changing: undefined | ClusterEvents.AttributeObservable<OptionalWritableAttribute<BtUh, any>>;
    acCoilTemperature$Changing: undefined | ClusterEvents.AttributeObservable<OptionalAttribute<null | number, any>>;
    acCompressorType$Changing: undefined | ClusterEvents.AttributeObservable<OptionalWritableAttribute<Thermostat.AcCompressorType, any>>;
    acErrorCode$Changing: undefined | ClusterEvents.AttributeObservable<OptionalWritableAttribute<TypeFromPartialBitSchema<{
        coilSensorFail: BitFlag;
        compressorFail: BitFlag;
        fanFail: BitFlag;
        outdoorSensorFail: BitFlag;
        roomSensorFail: BitFlag;
    }>, any>>;
    acLouverPosition$Changing: undefined | ClusterEvents.AttributeObservable<OptionalWritableAttribute<Thermostat.AcLouverPosition, any>>;
    acRefrigerantType$Changing: undefined | ClusterEvents.AttributeObservable<OptionalWritableAttribute<Thermostat.AcRefrigerantType, any>>;
    acType$Changing: undefined | ClusterEvents.AttributeObservable<OptionalWritableAttribute<Thermostat.AcType, any>>;
    emergencyHeatDelta$Changing: undefined | ClusterEvents.AttributeObservable<OptionalWritableAttribute<number, any>>;
    outdoorTemperature$Changing: undefined | ClusterEvents.AttributeObservable<OptionalAttribute<null | number, any>>;
    remoteSensing$Changing: undefined | ClusterEvents.AttributeObservable<OptionalWritableAttribute<TypeFromPartialBitSchema<{
        localTemperature: BitFlag;
        occupancy: BitFlag;
        outdoorTemperature: BitFlag;
    }>, any>>;
    setpointChangeAmount$Changing: undefined | ClusterEvents.AttributeObservable<OptionalAttribute<null | number, any>>;
    setpointChangeSource$Changing: undefined | ClusterEvents.AttributeObservable<OptionalAttribute<Thermostat.SetpointChangeSource, any>>;
    setpointChangeSourceTimestamp$Changing: undefined | ClusterEvents.AttributeObservable<OptionalAttribute<number, any>>;
    temperatureSetpointHold$Changing: undefined | ClusterEvents.AttributeObservable<OptionalWritableAttribute<Thermostat.TemperatureSetpointHold, any>>;
    temperatureSetpointHoldDuration$Changing: undefined | ClusterEvents.AttributeObservable<OptionalWritableAttribute<null | number, any>>;
    thermostatProgrammingOperationMode$Changing: undefined | ClusterEvents.AttributeObservable<OptionalWritableAttribute<TypeFromPartialBitSchema<{
        autoRecovery: BitFlag;
        economy: BitFlag;
        scheduleActive: BitFlag;
    }>, any>>;
    thermostatRunningState$Changing: undefined | ClusterEvents.AttributeObservable<OptionalAttribute<TypeFromPartialBitSchema<{
        cool: BitFlag;
        coolStage2: BitFlag;
        fan: BitFlag;
        fanStage2: BitFlag;
        fanStage3: BitFlag;
        heat: BitFlag;
        heatStage2: BitFlag;
    }>, any>>;
} & {
    controlSequenceOfOperation$Changed: ClusterEvents.AttributeObservable<WritableAttribute<Thermostat.ControlSequenceOfOperation, any>>;
    localTemperature$Changed: ClusterEvents.AttributeObservable<Attribute<null | number, any>>;
    systemMode$Changed: ClusterEvents.AttributeObservable<WritableAttribute<Thermostat.SystemMode, any>>;
} & {
    acCapacity$Changed: undefined | ClusterEvents.AttributeObservable<OptionalWritableAttribute<number, any>>;
    acCapacityFormat$Changed: undefined | ClusterEvents.AttributeObservable<OptionalWritableAttribute<BtUh, any>>;
    acCoilTemperature$Changed: undefined | ClusterEvents.AttributeObservable<OptionalAttribute<null | number, any>>;
    acCompressorType$Changed: undefined | ClusterEvents.AttributeObservable<OptionalWritableAttribute<Thermostat.AcCompressorType, any>>;
    acErrorCode$Changed: undefined | ClusterEvents.AttributeObservable<OptionalWritableAttribute<TypeFromPartialBitSchema<{
        coilSensorFail: BitFlag;
        compressorFail: BitFlag;
        fanFail: BitFlag;
        outdoorSensorFail: BitFlag;
        roomSensorFail: BitFlag;
    }>, any>>;
    acLouverPosition$Changed: undefined | ClusterEvents.AttributeObservable<OptionalWritableAttribute<Thermostat.AcLouverPosition, any>>;
    acRefrigerantType$Changed: undefined | ClusterEvents.AttributeObservable<OptionalWritableAttribute<Thermostat.AcRefrigerantType, any>>;
    acType$Changed: undefined | ClusterEvents.AttributeObservable<OptionalWritableAttribute<Thermostat.AcType, any>>;
    emergencyHeatDelta$Changed: undefined | ClusterEvents.AttributeObservable<OptionalWritableAttribute<number, any>>;
    outdoorTemperature$Changed: undefined | ClusterEvents.AttributeObservable<OptionalAttribute<null | number, any>>;
    remoteSensing$Changed: undefined | ClusterEvents.AttributeObservable<OptionalWritableAttribute<TypeFromPartialBitSchema<{
        localTemperature: BitFlag;
        occupancy: BitFlag;
        outdoorTemperature: BitFlag;
    }>, any>>;
    setpointChangeAmount$Changed: undefined | ClusterEvents.AttributeObservable<OptionalAttribute<null | number, any>>;
    setpointChangeSource$Changed: undefined | ClusterEvents.AttributeObservable<OptionalAttribute<Thermostat.SetpointChangeSource, any>>;
    setpointChangeSourceTimestamp$Changed: undefined | ClusterEvents.AttributeObservable<OptionalAttribute<number, any>>;
    temperatureSetpointHold$Changed: undefined | ClusterEvents.AttributeObservable<OptionalWritableAttribute<Thermostat.TemperatureSetpointHold, any>>;
    temperatureSetpointHoldDuration$Changed: undefined | ClusterEvents.AttributeObservable<OptionalWritableAttribute<null | number, any>>;
    thermostatProgrammingOperationMode$Changed: undefined | ClusterEvents.AttributeObservable<OptionalWritableAttribute<TypeFromPartialBitSchema<{
        autoRecovery: BitFlag;
        economy: BitFlag;
        scheduleActive: BitFlag;
    }>, any>>;
    thermostatRunningState$Changed: undefined | ClusterEvents.AttributeObservable<OptionalAttribute<TypeFromPartialBitSchema<{
        cool: BitFlag;
        coolStage2: BitFlag;
        fan: BitFlag;
        fanStage2: BitFlag;
        fanStage3: BitFlag;
        heat: BitFlag;
        heatStage2: BitFlag;
    }>, any>>;
} & {} & {}

Access the behavior's events.

features

features: TypeFromBitSchema<{}> & TypeFromBitSchema<{
    autoMode: BitFlag;
    cooling: BitFlag;
    heating: BitFlag;
    localTemperatureNotExposed: BitFlag;
    occupancy: BitFlag;
    scheduleConfiguration: BitFlag;
    setback: BitFlag;
}>

Supported features as a flag object.

session

session: SecureSession

Readonlystate

state: Omit<ClusterState.Type<Of<{
    attributes: {};
    commands: {};
    events: {};
    id: 0;
    name: "Unknown";
    revision: 0;
}>, typeof ClusterBehavior>, never> & {
    controlSequenceOfOperation: Thermostat.ControlSequenceOfOperation;
    localTemperature: null | number;
    systemMode: Thermostat.SystemMode;
} & {
    acCapacity?: number;
    acCapacityFormat?: BtUh;
    acCoilTemperature?: null | number;
    acCompressorType?: Thermostat.AcCompressorType;
    acErrorCode?: TypeFromPartialBitSchema<{
        coilSensorFail: BitFlag;
        compressorFail: BitFlag;
        fanFail: BitFlag;
        outdoorSensorFail: BitFlag;
        roomSensorFail: BitFlag;
    }>;
    acLouverPosition?: Thermostat.AcLouverPosition;
    acRefrigerantType?: Thermostat.AcRefrigerantType;
    acType?: Thermostat.AcType;
    emergencyHeatDelta?: number;
    outdoorTemperature?: null | number;
    remoteSensing?: TypeFromPartialBitSchema<{
        localTemperature: BitFlag;
        occupancy: BitFlag;
        outdoorTemperature: BitFlag;
    }>;
    setpointChangeAmount?: null | number;
    setpointChangeSource?: Thermostat.SetpointChangeSource;
    setpointChangeSourceTimestamp?: number;
    temperatureSetpointHold?: Thermostat.TemperatureSetpointHold;
    temperatureSetpointHoldDuration?: null | number;
    thermostatProgrammingOperationMode?: TypeFromPartialBitSchema<{
        autoRecovery: BitFlag;
        economy: BitFlag;
        scheduleActive: BitFlag;
    }>;
    thermostatRunningState?: TypeFromPartialBitSchema<{
        cool: BitFlag;
        coolStage2: BitFlag;
        fan: BitFlag;
        fanStage2: BitFlag;
        fanStage3: BitFlag;
        heat: BitFlag;
        heatStage2: BitFlag;
    }>;
} & {} & {}

Access the behavior's state.

Static Readonlycluster

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

Base cluster state include all attribute values but may be extended by subclasses.

Static Readonlydefaults

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

Static Optional Readonlydependencies

dependencies?: Iterable<Type, any, any>

Static Readonlyearly

early: boolean

Static ReadonlyEvents

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

Static ReadonlyExtensionInterface

ExtensionInterface: {}

Static Readonlyid

id

The behavior ID for ClusterBehaviors is the name of the cluster.

Static ReadonlyInterface

Interface: ThermostatInterface

Static ReadonlyInternal

Internal: (new () => {})

Type declaration

    • new (): {}

    • Implementation of internal state. Subclasses may override to extend.

      Returns {}

    Static Readonlyname

    name: string

    Static Optional Readonlyschema

    schema?: Schema

    Static ReadonlyState

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

    Static Readonlysupervisor

    supervisor: RootSupervisor

    Staticsupports

    supports: ((other: Type) => boolean)

    Type declaration

      • (other): boolean

      • Does this behavior support functionality of a specific implementation?

        Parameters

        Returns boolean

    Methods

    [asyncDispose]

    asAdmin

    • asAdmin(fn): void

    • Execute logic with elevated privileges.

      The provided function executes with privileges escalated to offline mode. This is not commonly necessary.

      Elevated logic effectively ignores ACLs so should be used with care.

      Note that interactions with the behavior will remain elevated until the synchronous completion of this call. You should only elevate privileges for synchronous logic.

      Parameters

      • fn: (() => void)

        the elevated logic

          • (): void

          • Returns void

      Returns void

    assertAttributeEnabled

    • assertAttributeEnabled<This, K>(this, attributeName): void

    • Type Parameters

      • This extends Behavior
      • K extends string | number | symbol

      Parameters

      • this: This
      • attributeName: K

      Returns void

    Protectedcallback

    • callback<A, R>(reactor, options?): ((...args: A) => undefined | R)

    • Create a generic callback function that has the same properties as a Reactor.

      Like a reactor, the callback's "this" will be bound to an active Behavior instance. Because of this: The reactor MUST be a real JS function - arrow functions will not work!

      Type Parameters

      • A extends any[]
      • R

      Parameters

      Returns ((...args: A) => undefined | R)

        • (...args): undefined | R

        • Parameters

          • Rest...args: A

          Returns undefined | R

    initialize

    • initialize(_options?): MaybePromise

    • Behaviors are ephemeral and should not perform initialization in their constructor. They can override this method instead.

      This method may be synchronous or asyncronous. If asynchronous, the behavior will not be available for external use until initialization completes.

      Parameters

      • Optional_options: {}

        Returns MaybePromise

      ProtectedreactTo

      • reactTo<O>(observable, reactor, options?): void

      • Install a Reactor.

        Important: The reactor MUST be a real JS function - arrow functions will not work!

        Type Parameters

        Parameters

        Returns void

      requireAttributeEnabled

      • requireAttributeEnabled<This, K>(this, attributeName): Exclude<This["state"][K], undefined>

      • Type Parameters

        • This extends Behavior
        • K extends string | number | symbol

        Parameters

        • this: This
        • attributeName: K

        Returns Exclude<This["state"][K], undefined>

      setpointRaiseLower

      • setpointRaiseLower(request): MaybePromise

      • Upon receipt, the attributes for the indicated setpoint(s) shall have the amount specified in the Amount field added to them. If the resulting value is outside the limits imposed by MinCoolSetpointLimit, MaxCoolSetpointLimit, MinHeatSetpointLimit and MaxHeatSetpointLimit, the value is clamped to those limits. This is not considered an error condition.

        Parameters

        Returns MaybePromise

        See

        MatterSpecification.v13.Cluster § 4.3.10.1

      toString

      • toString(): string

      • Description used in diagnostic messages.

        Returns string

      Staticalter

      Staticenable

      Staticfor

      Staticset

      • set<This>(this, defaults): This

      • Type Parameters

        Parameters

        Returns This

      Staticwith

      Settings

      Member Visibility

      On This Page

      Constructors
      Properties
      Methods