homebridge-dummy 1.3.2 → 1.4.0-beta.1

package/CHANGELOG.md

@@ -2,7 +2,7 @@
 
 All notable changes to homebridge-dummy will be documented in this file.
 
-## 1.3.2 (2025-10-24)
+## 1.4.0-beta.1 (2025-10-25)
 
 ### ‼️ WARNING ‼️ — If upgrading from v0.9.2 or earlier, [READ THIS FIRST](https://github.com/mpatfield/homebridge-dummy?tab=readme-ov-file#v10-migration)
 
@@ -10,6 +10,17 @@ All notable changes to homebridge-dummy will be documented in this file.
 
 I plan to remove `Thermostat` as a supported accessory type from a future version. If you use `Thermostat`, please add your use case to [this ticket](https://github.com/mpatfield/homebridge-dummy/issues/207) and I will help you find an alternative.
 
+### Added
+- Trigger Conditions ([docs](https://github.com/mpatfield/homebridge-dummy?tab=readme-ov-file#trigger-conditions)) to trigger an accessory based on the state changes of other Homebridge Dummy accessories
+    - ⚠️ Config UI for conditions is highly experimental. Please [open a ticket](https://github.com/mpatfield/homebridge-dummy/issues/new/choose) if you see any unusal behavior.
+- Fade Out option for `Lightbulb` brightness to make a simple "count-down"
+
+### Changed
+- `defaultOn` has been deprecated in favor of `defaultState` for `Lightbulb`, `Outlet`, and `Switch`
+    - This is backwards compatible so no manual edits are necessary
+
+## 1.3.2 (2025-10-24)
+
 ### Added
 - Support for `GarageDoorOpener`
 - Русский перевод. Спасибо, [@Silverdragon122](https://github.com/sponsors/Silverdragon122)!

package/README.md

@@ -123,9 +123,20 @@ Using the Homebridge Config UI is the easiest way to set up this plugin. However
                 "units": "MILLISECONDS | SECONDS | MINUTES | HOURS",
                 "period": "HOUR | DAY | WEEK | MONTH",
             },
+            "conditions": {
+                "operator": "and | or",
+                "operands" [
+                    {
+                        "accessoryId": "string",
+                        "accessoryState": "on | off | open | closed | locked | unlocked",
+                    }
+                    …
+                ]
+            },
             "temperatureUnits": "C" | "F",
-            "defaultOn": true | false,
+            "defaultState": "on" | "off",
             "defaultBrightness": 0-100,
+            "fadeOut": true | false,
             "defaultLockState": "locked" | "unlocked",
             "defaultPosition": "open" | "closed",
             "defaultThermostatState": "auto" | "heat" | "cool" | "off",
@@ -221,10 +232,33 @@ Execute arbitrary commands (e.g. curl) when the accessory changes state
 - `unlockCommand` - Arbitrary command to execute when lock mechanism is unlocked
 - `commandTemperature` - Arbitrary command to execute when temperature changes
 
+### Trigger Conditions
+
+You can trigger an accessory whenever a set of conditions are satisfied, for example, when other Homebridge Dummy accessories turn on.
+
+There are two logical operators to trigger the target accessory when ALL ("and") or ANY ("or") of a set of conditions are satisfied. This is set using `operator`.
+
+You can have an arbitrarily long list of conditions and they are checked in order.
+
+If target accessory is not setup to auto-reset with a timer, then it will immediately return to it's default setting as soon as the conditions are no longer met.
+
+Note that due to limitations of HomeKit and Homebridge, it is only possible to check the states of other Homebridge Dummy accessories. One possible workaround is to set up duplicate accessories in Homebridge Dummy and use Automation to mirror the states.
+
+For example, if I have a physical door lock I want to "watch", then I can setup a `LockMechanism` accessory in Homebridge Dummy and create two automations to change the state of my dummy lock whenever the physical door lock is unlocked or locked.
+
+#### Conditions Object
+- `operator` - "and" to require ALL conditions to be satisfied, and "or" ANY
+- `operands` - A list of accessories to "watch" for state changes to see if conditions are satisfied
+
+#### Operand Object
+- `accessoryId` - The id of the accessory to watch for state changes
+- `accessoryState` - The desired accessory state to make this condition "true"
+
 ### Defaults
 - `temperatureUnits` - Units to use for thermostats, either 'C' or 'F'
-- `defaultOn` — Initial value. Default _ON_ = true, default _OFF_ = false
+- `defaultState` — Initial value, either "on" or "off"
 - `defaultBrightness` — If set, lightbulb will have additional dimmer settings with this default brightness percentage
+- `fadeOut` - Fade smoothly instead of abruptly from 100% to off. Requires `defaultBrightness` and `timer` to be defined.
 - `defaultLockState` - The initial value for the lock, "locked" or "unlocked"
 - `defaultPosition` — Initial position for the door/garage/window/blinds, "open" or "closed"
 - `defaultThermostatState` - The initial state for the thermostat, "auto", "heat", "cool", or "off"

package/config.schema.json

@@ -37,7 +37,10 @@
             "title": "${config.title.delay}",
             "minimum": 1
           },
-          "units": { "$ref": "#/definitions/units" },
+          "units": {
+            "$ref": "#/definitions/units",
+            "required": true
+          },
           "random": {
             "type": "boolean",
             "title": "${config.title.random}",
@@ -158,13 +161,15 @@
             "type": "string",
             "title": "${config.title.units}",
             "enum": [ "SECONDS", "MINUTES", "HOURS"],
-            "enumNames": ["${config.enumNames.seconds}", "${config.enumNames.minutes}", "${config.enumNames.hours}"]
+            "enumNames": ["${config.enumNames.seconds}", "${config.enumNames.minutes}", "${config.enumNames.hours}"],
+            "required": true
           },
           "period": {
             "type": "string",
             "title": "${config.title.period}",
             "enum": [ "HOUR", "DAY", "WEEK", "MONTH"],
-            "enumNames": ["${config.enumNames.hour}", "${config.enumNames.day}", "${config.enumNames.week}", "${config.enumNames.month}"]
+            "enumNames": ["${config.enumNames.hour}", "${config.enumNames.day}", "${config.enumNames.week}", "${config.enumNames.month}"],
+            "required": true
           }
         },
         "allOf": [
@@ -205,6 +210,53 @@
             }
           }
         ]
+      },
+      "operand": {
+        "type": "object",
+        "properties": {
+          "accessoryId": {
+            "type": "string",
+            "title": "${config.title.accessory}",
+            "required": true
+          },
+          "accessoryState": {
+            "type": "string",
+            "title": "${config.title.accessoryState}",
+            "enum": [ "on", "off", "open", "closed", "locked", "unlocked" ],
+            "enumNames": [ "${config.enumNames.on}", "${config.enumNames.off}", "${config.enumNames.open}", "${config.enumNames.closed}", "${config.enumNames.secured}", "${config.enumNames.unsecured}" ],
+            "required": true
+          }
+        }
+      },
+      "conditions": {
+        "type": "object",
+        "properties": {
+          "operator": {
+            "type": "string",
+            "title": "${config.title.operator}",
+            "enum": [ "and", "or"],
+            "enumNames": ["${config.enumNames.operatorAnd}", "${config.enumNames.operatorOr}"]
+          },
+          "operands": {
+            "type": "array",
+            "minItems":1,
+            "items": { "$ref": "#/definitions/operand" }
+          }
+        },
+        "allOf": [
+          {
+            "if": {
+              "properties": {
+                "operator": {
+                }
+              },
+              "required": ["operator"]
+            },
+            "then": {
+              "required": ["operands"]
+            }
+          }
+        ]
       }
     },
     "properties": {
@@ -239,6 +291,7 @@
             "timer": { "$ref": "#/definitions/timer" },
             "schedule": { "$ref": "#/definitions/schedule" },
             "limiter": { "$ref": "#/definitions/limiter" },
+            "conditions": { "$ref": "#/definitions/conditions" },
             "temperatureUnits": {
               "type": "string",
               "title": "${config.title.units}",
@@ -251,10 +304,15 @@
               "minimum": 0,
               "maximum": 100
             },
-            "defaultOn": {
-              "type": "number",
+            "fadeOut": {
+              "type": "boolean",
+              "title": "${config.title.fadeOut}",
+              "description": "${config.description.fadeOut}"
+            },
+            "defaultState": {
+              "type": "string",
               "title": "${config.title.defaultState}",
-              "enum": [1, 0],
+              "enum": ["on", "off"],
               "enumNames": ["${config.enumNames.on}", "${config.enumNames.off}"]
             },
             "defaultLockState": {
@@ -348,15 +406,15 @@
               "items": [
                 {
                   "key": "accessories[].name",
-                  "flex": "1 1 33%"
+                  "flex": "0 0 33%"
                 },
                 {
                   "key": "accessories[].type",
-                  "flex": "1 1 33%"
+                  "flex": "0 0 33%"
                 },
                 {
                   "key": "accessories[].groupName",
-                  "flex": "1 1 33%"
+                  "flex": "0 0 33%"
                 }
               ]
             },
@@ -364,7 +422,7 @@
               "type": "fieldset",
               "notitle": true,
               "condition": {
-                "functionBody": "return model.accessories?.[arguments[1]]?.type !== undefined;"
+                "functionBody": "return model.accessories?.[arguments[1]]?.type;"
               },
               "items": [
                 {
@@ -376,7 +434,7 @@
                   },
                   "items": [
                     {
-                      "key": "accessories[].defaultOn",
+                      "key": "accessories[].defaultState",
                       "flex": "0 0 33%"
                     },
                     {
@@ -387,7 +445,7 @@
                       "key": "accessories[].defaultBrightness",
                       "flex": "0 0 33%",
                       "condition": {
-                        "functionBody": "return ['Lightbulb'].includes(model.accessories?.[arguments[1]]?.type);"
+                        "functionBody": "return model.accessories?.[arguments[1]]?.type === 'Lightbulb';"
                       }
                     }
                   ]
@@ -479,7 +537,7 @@
               "title": "${config.title.schedule}",
               "description": "${config.description.schedule}",
               "condition": {
-                "functionBody": "const type = model.accessories?.[arguments[1]]?.type; return type !== undefined && type !== 'Thermostat';"
+                "functionBody": "const type = model.accessories?.[arguments[1]]?.type; return type && type !== 'Thermostat';"
               },
               "items": [
                 {
@@ -489,18 +547,18 @@
                   "items": [
                     {
                       "key": "accessories[].schedule.type",
-                      "flex": "1 1 33%"
+                      "flex": "0 0 33%"
                     },
                     {
                       "key": "accessories[].schedule.interval",
-                      "flex": "1 1 33%",
+                      "flex": "0 0 33%",
                       "condition": {
                           "functionBody": "return model.accessories?.[arguments[1]]?.schedule?.type === 'INTERVAL';"
                       }
                     },
                     {
                       "key": "accessories[].schedule.units",
-                      "flex": "1 1 33%",
+                      "flex": "0 0 33%",
                       "condition": {
                           "functionBody": "return model.accessories?.[arguments[1]]?.schedule?.type === 'INTERVAL';"
                       }
@@ -517,11 +575,11 @@
                   "items": [
                     {
                       "key": "accessories[].schedule.cron",
-                      "flex": "1 1 33%"
+                      "flex": "0 0 33%"
                     },
                     {
                       "key": "accessories[].schedule.cronCustom",
-                      "flex": "1 1 67%",
+                      "flex": "0 0 67%",
                       "condition": {
                           "functionBody": "return model.accessories?.[arguments[1]]?.schedule?.cron === 'CRON_CUSTOM';"
                       }
@@ -531,7 +589,7 @@
                 {
                   "key": "accessories[].schedule.random",
                   "condition": {
-                      "functionBody": "const schedule = model.accessories?.[arguments[1]]?.schedule; return schedule?.type === 'INTERVAL' && schedule?.interval !== undefined;"
+                      "functionBody": "const schedule = model.accessories?.[arguments[1]]?.schedule; return schedule?.type === 'INTERVAL' && schedule?.interval;"
                   }
                 }
               ]
@@ -541,7 +599,7 @@
               "title": "${config.title.timer}",
               "description": "${config.description.timer}",
               "condition": {
-                "functionBody": "const type = model.accessories?.[arguments[1]]?.type; return type !== undefined && type !== 'Thermostat';"
+                "functionBody": "const type = model.accessories?.[arguments[1]]?.type; return type && type !== 'Thermostat';"
               },
               "items": [
                 {
@@ -551,11 +609,14 @@
                   "items": [
                     {
                       "key": "accessories[].timer.delay",
-                      "flex": "1 1 33%"
+                      "flex": "0 0 33%"
                     },
                     {
                       "key": "accessories[].timer.units",
-                      "flex": "1 1 33%"
+                      "flex": "0 0 33%",
+                      "condition": {
+                        "functionBody": "return model.accessories?.[arguments[1]]?.timer?.delay;"
+                      }
                     }
                   ]
                 },
@@ -563,14 +624,21 @@
                   "type": "fieldset",
                   "notitle": true,
                   "condition": {
-                    "functionBody": "return model.accessories?.[arguments[1]]?.timer?.delay !== undefined;"
+                    "functionBody": "return model.accessories?.[arguments[1]]?.timer?.delay;"
                   },
                   "items": [
                     "accessories[].timer.random",
+                    {
+                      "key": "accessories[].fadeOut",
+                      "flex": "1 0 33%",
+                      "condition": {
+                        "functionBody": "return model.accessories?.[arguments[1]]?.defaultBrightness !== undefined && model.accessories?.[arguments[1]]?.defaultState !== 'on' && model.accessories?.[arguments[1]]?.timer?.delay !== undefined;"
+                      }
+                    },
                     {
                       "key": "accessories[].sensor.timerControlled",
                       "condition": {
-                          "functionBody": "return model.accessories?.[arguments[1]]?.sensor?.type !== undefined;"
+                          "functionBody": "return model.accessories?.[arguments[1]]?.sensor?.type;"
                       }
                     }
                   ]
@@ -582,7 +650,7 @@
               "title": "${config.title.limiter}",
               "description": "${config.description.limiter}",
               "condition": {
-                "functionBody": "const type = model.accessories?.[arguments[1]]?.type; return type !== undefined && type !== 'Thermostat';"
+                "functionBody": "const type = model.accessories?.[arguments[1]]?.type; return type && type !== 'Thermostat';"
               },
               "items": [
                 {
@@ -592,15 +660,71 @@
                   "items": [
                     {
                       "key": "accessories[].limiter.limit",
-                      "flex": "1 1 33%"
+                      "flex": "0 0 33%"
                     },
                     {
                       "key": "accessories[].limiter.units",
-                      "flex": "1 1 33%"
+                      "flex": "0 0 33%",
+                      "condition": {
+                        "functionBody": "return model.accessories?.[arguments[1]]?.limiter?.limit;"
+                      }
                     },
                     {
                       "key": "accessories[].limiter.period",
-                      "flex": "1 1 33%"
+                      "flex": "0 0 33%",
+                      "condition": {
+                        "functionBody": "return model.accessories?.[arguments[1]]?.limiter?.limit;"
+                      }
+                    }
+                  ]
+                }
+              ]
+            },
+            {
+              "type": "fieldset",
+              "title": "${config.title.conditions}",
+              "description": "${config.description.conditions}",
+              "condition": {
+                "functionBody": "const type = model.accessories?.[arguments[1]]?.type; return model.accessories?.length > 1 && type && type !== 'Thermostat'"
+              },
+              "items": [
+                {
+                  "type": "div",
+                  "displayFlex": true,
+                  "flex-direction": "row",
+                  "items": [
+                    {
+                      "key": "accessories[].conditions.operator",
+                      "flex": "0 0 67%"
+                    }
+                  ]
+                },
+                {
+                  "type": "array",
+                  "title": "${config.title.condition}",
+                  "notitle": true,
+                  "condition": {
+                    "functionBody": "return model.accessories?.[arguments[1]]?.conditions?.operator;"
+                  },
+                  "key": "accessories[].conditions.operands",
+                  "items": [
+                    {
+                      "type": "div",
+                      "displayFlex": true,
+                      "flex-direction": "row",
+                      "items": [
+                        {
+                          "key": "accessories[].conditions.operands[].accessoryId",
+                          "flex": "0 0 50%"
+                        },
+                        {
+                          "key": "accessories[].conditions.operands[].accessoryState",
+                          "flex": "0 0 50%",
+                          "condition": {
+                            "functionBody": "return model.accessories?.[arguments[1][0]]?.conditions?.operands?.[arguments[1][1]]?.accessoryId;"
+                          }
+                        }
+                      ]
                     }
                   ]
                 }
@@ -611,7 +735,7 @@
               "title": "${config.title.commands}",
               "description": "${config.description.commands}",
               "condition": {
-                "functionBody": "return model.accessories?.[arguments[1]]?.type !== undefined;"
+                "functionBody": "return model.accessories?.[arguments[1]]?.type;"
               },
               "items": [
                 {

package/dist/accessory/base.d.ts

@@ -1,15 +1,30 @@
 import { PlatformAccessory, Service } from 'homebridge';
 import { SensorAccessory } from './sensor.js';
-import { AccessoryType } from '../model/enums.js';
+import { ConditionManager } from '../model/conditions.js';
+import { AccessoryState, AccessoryType } from '../model/enums.js';
 import { CharacteristicType, DummyConfig, ServiceType } from '../model/types.js';
 import { Webhook } from '../model/webhook.js';
 import { Log } from '../tools/log.js';
+export type DummyAccessoryDependency<C extends DummyConfig> = {
+    Service: ServiceType;
+    Characteristic: CharacteristicType;
+    platformAccessory: PlatformAccessory;
+    config: C;
+    conditionManager: ConditionManager;
+    log: Log;
+    isGrouped: boolean;
+};
+export type DummyAddonDependency = {
+    Service: ServiceType;
+    Characteristic: CharacteristicType;
+    platformAccessory: PlatformAccessory;
+    identifier: string;
+    caller: string;
+    log: Log;
+    disableLogging: boolean;
+};
 export declare abstract class DummyAccessory<C extends DummyConfig> {
-    protected readonly Service: ServiceType;
-    protected readonly Characteristic: CharacteristicType;
-    protected readonly accessory: PlatformAccessory;
-    protected readonly config: C;
-    protected readonly log: Log;
+    private readonly dependency;
     protected sensor?: SensorAccessory;
     static identifier(config: DummyConfig): string;
     protected readonly accessoryService: Service;
@@ -17,20 +32,25 @@ export declare abstract class DummyAccessory<C extends DummyConfig> {
     private readonly _timer?;
     private readonly _limiter?;
     private readonly execAsync;
-    constructor(Service: ServiceType, Characteristic: CharacteristicType, accessory: PlatformAccessory, config: C, log: Log, isGrouped: boolean);
+    constructor(dependency: DummyAccessoryDependency<C>);
     protected abstract getAccessoryType(): AccessoryType;
-    protected abstract schedule(): Promise<void>;
+    protected abstract trigger(): Promise<void>;
     protected abstract reset(): Promise<void>;
     get subtype(): string | undefined;
     teardown(): void;
     abstract webhooks(): Webhook[];
+    protected get config(): C;
     protected get identifier(): string;
     protected get name(): string;
+    protected get log(): Log;
+    protected get Characteristic(): CharacteristicType;
     protected get isStateful(): boolean;
     protected get defaultStateStorageKey(): string;
     protected startTimer(): void;
+    protected onTimerStarted(_delay: number): void;
     protected cancelTimer(): void;
     protected executeCommand(command: string): Promise<void>;
     private isExecException;
+    protected onStateChange(state: AccessoryState): Promise<void>;
     protected logIfDesired(message: string, ...parameters: (string | number)[]): void;
 }

package/dist/accessory/base.js

@@ -9,11 +9,7 @@ import { Schedule } from '../timeout/schedule.js';
 import { Timer } from '../timeout/timer.js';
 import getVersion from '../tools/version.js';
 export class DummyAccessory {
-    Service;
-    Characteristic;
-    accessory;
-    config;
-    log;
+    dependency;
     sensor;
     static identifier(config) {
         return config.id ?? `${PLATFORM_NAME}:${config.type}:${config.name.replace(/\s+/g, '')}`;
@@ -23,44 +19,47 @@ export class DummyAccessory {
     _timer;
     _limiter;
     execAsync = promisify(exec);
-    constructor(Service, Characteristic, accessory, config, log, isGrouped) {
-        this.Service = Service;
-        this.Characteristic = Characteristic;
-        this.accessory = accessory;
-        this.config = config;
-        this.log = log;
-        this.sensor = SensorAccessory.new(Service, Characteristic, accessory, this.name, log, this.config.disableLogging === true, config.sensor);
-        if (config.timer) {
-            this._timer = Timer.new(config.timer, this.identifier, config.name, log, config.disableLogging === true);
-        }
-        if (config.schedule) {
-            this._schedule = Schedule.new(config.schedule, config.name, log, config.disableLogging === true, this.schedule.bind(this));
-        }
-        if (config.limiter) {
-            this._limiter = Limiter.new(config.limiter, config.name, log, config.disableLogging === true);
-        }
-        const serviceInstance = Service[this.getAccessoryType()];
-        if (isGrouped) {
-            let accessoryService = accessory.getServiceById(serviceInstance, this.identifier);
+    constructor(dependency) {
+        this.dependency = dependency;
+        const name = dependency.config.name;
+        const disableLogging = dependency.config.disableLogging === true;
+        const addonDependency = {
+            Service: dependency.Service,
+            Characteristic: dependency.Characteristic,
+            platformAccessory: dependency.platformAccessory,
+            identifier: this.identifier,
+            caller: name,
+            log: dependency.log,
+            disableLogging: disableLogging,
+        };
+        this.sensor = SensorAccessory.new(addonDependency, dependency.config.sensor);
+        this._timer = Timer.new(addonDependency, dependency.config.timer);
+        this._schedule = Schedule.new(addonDependency, dependency.config.schedule, this.trigger.bind(this));
+        this._limiter = Limiter.new(addonDependency, dependency.config.limiter);
+        dependency.conditionManager.register(name, this.identifier, dependency.config.conditions, this.trigger.bind(this), this._timer ? undefined : this.reset.bind(this), disableLogging);
+        const serviceInstance = dependency.Service[this.getAccessoryType()];
+        if (dependency.isGrouped) {
+            let accessoryService = dependency.platformAccessory.getServiceById(serviceInstance, this.identifier);
             if (!accessoryService) {
-                accessoryService = accessory.addService(serviceInstance, config.name, this.identifier);
-                accessoryService.setCharacteristic(Characteristic.ConfiguredName, config.name);
+                accessoryService = dependency.platformAccessory.addService(serviceInstance, name, this.identifier);
+                accessoryService.addOptionalCharacteristic(dependency.Characteristic.ConfiguredName);
+                accessoryService.setCharacteristic(dependency.Characteristic.ConfiguredName, name);
             }
             this.accessoryService = accessoryService;
             return;
         }
-        accessory.getService(Service.AccessoryInformation)
-            .setCharacteristic(Characteristic.Name, config.name)
-            .setCharacteristic(Characteristic.ConfiguredName, config.name)
-            .setCharacteristic(Characteristic.Manufacturer, PLUGIN_ALIAS)
-            .setCharacteristic(Characteristic.Model, config.type)
-            .setCharacteristic(Characteristic.SerialNumber, this.identifier)
-            .setCharacteristic(Characteristic.FirmwareRevision, getVersion());
-        this.accessoryService = accessory.getService(serviceInstance) || accessory.addService(serviceInstance);
+        dependency.platformAccessory.getService(dependency.Service.AccessoryInformation)
+            .setCharacteristic(dependency.Characteristic.Name, name)
+            .setCharacteristic(dependency.Characteristic.ConfiguredName, name)
+            .setCharacteristic(dependency.Characteristic.Manufacturer, PLUGIN_ALIAS)
+            .setCharacteristic(dependency.Characteristic.Model, dependency.config.type)
+            .setCharacteristic(dependency.Characteristic.SerialNumber, this.identifier)
+            .setCharacteristic(dependency.Characteristic.FirmwareRevision, getVersion());
+        this.accessoryService = dependency.platformAccessory.getService(serviceInstance) || dependency.platformAccessory.addService(serviceInstance);
         for (const type of Object.values(AccessoryType)) {
-            const existingService = accessory.getService(Service[type]);
+            const existingService = dependency.platformAccessory.getService(dependency.Service[type]);
             if (existingService && type !== this.getAccessoryType()) {
-                accessory.removeService(existingService);
+                dependency.platformAccessory.removeService(existingService);
             }
         }
     }
@@ -72,12 +71,21 @@ export class DummyAccessory {
         this._schedule?.teardown();
         this._limiter?.teardown();
     }
+    get config() {
+        return this.dependency.config;
+    }
     get identifier() {
         return DummyAccessory.identifier(this.config);
     }
     get name() {
         return this.config.name;
     }
+    get log() {
+        return this.dependency.log;
+    }
+    get Characteristic() {
+        return this.dependency.Characteristic;
+    }
     get isStateful() {
         return this._schedule === undefined && !this.config.resetOnRestart;
     }
@@ -85,9 +93,14 @@ export class DummyAccessory {
         return `${this.identifier}:DefaultState`;
     }
     startTimer() {
-        this._timer?.start(this.reset.bind(this));
+        if (this._timer) {
+            const delay = this._timer.start(this.reset.bind(this));
+            this.onTimerStarted(delay);
+        }
         this._limiter?.start(this.reset.bind(this));
     }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    onTimerStarted(_delay) { }
     cancelTimer() {
         this._timer?.cancel();
         this._limiter?.cancel();
@@ -128,6 +141,9 @@ export class DummyAccessory {
             'stderr' in err &&
             typeof err.stderr === 'string';
     }
+    async onStateChange(state) {
+        await this.dependency.conditionManager.onStateChange(this.identifier, state);
+    }
     logIfDesired(message, ...parameters) {
         if (this.config.disableLogging) {
             return;