homebridge-securitysystem 0.0.1-matter

package/src/handlers/state-handler.ts

@@ -0,0 +1,257 @@
+import type { Logging } from 'homebridge';
+import type { CharacteristicConstructor } from '../interfaces/hap-types-interface.js';
+import { SecurityState } from '../types/security-state-type.js';
+import { OriginType } from '../types/origin-type.js';
+import { stateToMode, capitalise } from '../utils/state-util.js';
+import { modeToState } from '../utils/state-util.js';
+import type { ServiceRegistry } from '../interfaces/service-registry-interface.js';
+import type { SystemState } from '../interfaces/system-state-interface.js';
+import type { SecuritySystemOptions } from '../interfaces/options-interface.js';
+import type { EventBusService } from '../services/event-bus-service.js';
+import { EventType } from '../types/event-type.js';
+import type { StorageService } from '../services/storage-service.js';
+import type { SensorHandler } from './sensor-handler.js';
+import type { TimerManager } from '../timers/timer-manager.js';
+import { getArmingSeconds } from '../utils/arming-util.js';
+import type { ServiceResult } from '../types/service-result-type.js';
+
+/**
+ * Manages the core security-system state machine: arming, triggering, and resetting.
+ * Cross-handler side effects are signalled via the event bus so that this class has
+ * no direct dependencies on TripHandler or SwitchHandler.
+ */
+export class StateHandler {
+  constructor(
+    private readonly services: ServiceRegistry,
+    private readonly state: SystemState,
+    private readonly options: SecuritySystemOptions,
+    private readonly Characteristic: CharacteristicConstructor,
+    private readonly log: Logging,
+    private readonly bus: EventBusService,
+    private readonly storageService: StorageService,
+    private readonly timers: TimerManager,
+    private readonly sensorHandler: SensorHandler,
+  ) {}
+
+  // ── Public API ─────────────────────────────────────────────────────────────
+
+  setCurrentState(state: SecurityState, origin: OriginType): void {
+    this.sensorHandler.resetArmingMotionSensor();
+
+    if (this.state.currentState === state) {
+      this.log.warn('Current mode (Already set)');
+      return;
+    }
+
+    this.state.currentState = state;
+    this.services.mainService.setCharacteristic(
+      this.Characteristic.SecuritySystemCurrentState,
+      state,
+    );
+    this.logMode('Current', state);
+
+    this.handleCurrentStateChange(origin);
+    this.storageService.save(this.state);
+  }
+
+  updateTargetState(state: SecurityState, origin: OriginType, delay: number): ServiceResult {
+    // Same-target re-call: "confirm this mode externally; apply it now"
+    if (state === this.state.targetState && this.state.currentState !== SecurityState.TRIGGERED) {
+      if (state === this.state.currentState) {
+        return { success: true };
+      }
+
+      if (this.state.isArming) {
+        this.timers.clearArmTimer();
+        this.state.isArming = false;
+      }
+
+      this.setCurrentState(state, origin);
+      return { success: true };
+    }
+
+    const reason = this.getBadTargetStateReason(state);
+    if (reason !== null) {
+      return { success: false, reason };
+    }
+
+    this.state.targetState = state;
+    this.logMode('Target', state);
+
+    if (origin === OriginType.INTERNAL || origin === OriginType.EXTERNAL) {
+      this.services.mainService.updateCharacteristic(
+        this.Characteristic.SecuritySystemTargetState,
+        state,
+      );
+    }
+
+    this.handleTargetStateChange(origin);
+
+    if (state === this.state.currentState) {
+      this.setCurrentState(state, origin);
+      return { success: true };
+    }
+
+    const armSeconds = delay > 0 ? delay : 0;
+
+    if (armSeconds === 0) {
+      this.setCurrentState(state, origin);
+      return { success: true };
+    }
+
+    this.state.isArming = true;
+    this.handleArmingState();
+    this.log.info(`Arm delay (${armSeconds}s)`);
+
+    this.timers.setArmTimer(armSeconds * 1000, () => {
+      this.state.isArming = false;
+      this.setCurrentState(state, origin);
+    });
+
+    return { success: true };
+  }
+
+  getArmingSeconds(targetState: SecurityState): number {
+    return getArmingSeconds(this.state, this.options, targetState);
+  }
+
+  resetTimers(): void {
+    this.timers.clearAll();
+  }
+
+  /** Returns true while the trigger delay is counting down (trip switch is active). */
+  isTripping(): boolean {
+    return this.state.isTripping;
+  }
+
+  /** Checks whether arming is currently blocked by an arming-lock switch. */
+  isArmingLocked(targetState: SecurityState): boolean {
+    // Locks never block disarming.
+    if (targetState === SecurityState.OFF) {
+      return false;
+    }
+
+    if (this.state.armingLocks.global) {
+      return true;
+    }
+
+    const modeMap: Partial<Record<SecurityState, keyof SystemState['armingLocks']>> = {
+      [SecurityState.HOME]: 'home',
+      [SecurityState.AWAY]: 'away',
+      [SecurityState.NIGHT]: 'night',
+    };
+
+    const lock = modeMap[targetState];
+    return lock ? this.state.armingLocks[lock] : false;
+  }
+
+  getAvailableTargetStates(): SecurityState[] {
+    const all = [SecurityState.HOME, SecurityState.AWAY, SecurityState.NIGHT, SecurityState.OFF];
+    const disabled = this.options.disabledModes.map(m => modeToState(m.toLowerCase()));
+    return all.filter(s => !disabled.includes(s));
+  }
+
+  logMode(type: string, state: SecurityState | string): void {
+    const mode = capitalise(stateToMode(state as SecurityState));
+    this.log.info(`${type} mode (${mode})`);
+  }
+
+  // ── Private helpers ────────────────────────────────────────────────────────
+
+  /**
+   * Returns a human-readable reason string if `state` is an invalid target,
+   * or `null` if the transition is permitted.
+   */
+  private getBadTargetStateReason(state: SecurityState): string | null {
+    const isTriggered = this.state.currentState === SecurityState.TRIGGERED;
+    const alreadySet = this.state.targetState === state;
+
+    if (alreadySet && !isTriggered) {
+      this.log.warn('Target mode (Already set)');
+      return 'target mode is already set';
+    }
+
+    if (!this.state.availableTargetStates.includes(state)) {
+      this.log.warn('Target mode (Disabled)');
+      return 'target mode is disabled';
+    }
+
+    const hasLock = this.options.armingLockSwitch || this.options.armingLockSwitches;
+    if (state !== SecurityState.OFF && hasLock && this.isArmingLocked(state)) {
+      this.log.warn('Arming lock (Not allowed)');
+      return 'arming is blocked by an arming lock switch';
+    }
+
+    return null;
+  }
+
+  private handleTargetStateChange(origin: OriginType): void {
+    this.resetTimers();
+
+    // The away-extended flag only applies to the arm cycle it started; any
+    // subsequent target change clears it (mirrors the HAP mode-switch reset).
+    this.state.modeAwayExtended = false;
+
+    // Notify handlers to reset their displayed state (bus is synchronous).
+    this.bus.emit(EventType.RESET_TRIP_SWITCHES, {});
+    this.sensorHandler.resetTrippedMotionSensor();
+    this.bus.emit(EventType.RESET_MODE_SWITCHES, {});
+    this.bus.emit(EventType.UPDATE_MODE_SWITCHES, {});
+
+    this.bus.emit(EventType.TARGET_CHANGED, { state: this.state.targetState, origin });
+
+    if (this.state.currentState === SecurityState.TRIGGERED) {
+      this.sensorHandler.pulseResetMotionSensor();
+    }
+
+    this.state.isTripping = false;
+    this.state.isKnocked = false;
+  }
+
+  private handleCurrentStateChange(origin: OriginType): void {
+    if (this.state.currentState === SecurityState.TRIGGERED) {
+      this.handleTriggeredState();
+
+      if (this.options.testMode) {
+        return;
+      }
+    } else {
+      // Notify TripHandler to reset trip switches on any non-triggered state change.
+      // (Do not reset when entering TRIGGERED — the trip switch should remain ON
+      // to reflect the active sensor / cause of the alarm.)
+      this.bus.emit(EventType.RESET_TRIP_SWITCHES, {});
+    }
+
+    this.bus.emit(EventType.CURRENT_CHANGED, { state: this.state.currentState, origin });
+  }
+
+  private handleTriggeredState(): void {
+    this.timers.clearTrippedInterval();
+    this.sensorHandler.resetTrippedMotionSensor();
+
+    this.timers.setResetTimer(this.options.resetMinutes * 60 * 1000, () => {
+      this.log.info('Reset (Finished)');
+      this.sensorHandler.pulseResetMotionSensor();
+
+      if (this.options.resetOffFlow) {
+        this.resetViaOffMode();
+      } else {
+        this.setCurrentState(this.state.targetState, OriginType.EXTERNAL);
+      }
+    });
+  }
+
+  private handleArmingState(): void {
+    this.sensorHandler.updateArmingMotionSensor(true);
+    this.bus.emit(EventType.ARMING, { state: this.state.targetState });
+  }
+
+  private resetViaOffMode(): void {
+    const original = this.state.targetState;
+    this.updateTargetState(SecurityState.OFF, OriginType.INTERNAL, 0);
+
+    setTimeout(() => {
+      this.updateTargetState(original, OriginType.INTERNAL, this.getArmingSeconds(original));
+    }, 100);
+  }
+}

package/src/handlers/switch-handler.ts

@@ -0,0 +1,111 @@
+import type { Logging } from 'homebridge';
+import { SecurityState } from '../types/security-state-type.js';
+import { OriginType } from '../types/origin-type.js';
+import type { SystemState } from '../interfaces/system-state-interface.js';
+import type { SecuritySystemOptions } from '../interfaces/options-interface.js';
+import type { StateHandler } from './state-handler.js';
+import { capitalise } from '../utils/state-util.js';
+import type { TimerManager } from '../timers/timer-manager.js';
+import type { ServiceResult } from '../types/service-result-type.js';
+
+/**
+ * Handles all mode switches and the pause/extended switches.
+ * Switches are published over Matter only; the HAP layer no longer carries them,
+ * so every method reports outcomes as ServiceResult which MatterService maps to
+ * Matter status errors. The switch display state is pushed to Matter via bus
+ * events handled by MatterService.
+ */
+export class SwitchHandler {
+  constructor(
+    private readonly state: SystemState,
+    private readonly options: SecuritySystemOptions,
+    private readonly log: Logging,
+    private readonly timers: TimerManager,
+    private readonly stateHandler: StateHandler,
+  ) {}
+
+  // ── Mode switches ──────────────────────────────────────────────────────────
+
+  setModeSwitch(mode: SecurityState, value: boolean): ServiceResult {
+    if (!value) {
+      return { success: false, reason: 'a mode switch can only be turned on' };
+    }
+    const delay = this.stateHandler.getArmingSeconds(mode);
+    return this.stateHandler.updateTargetState(mode, OriginType.INTERNAL, delay);
+  }
+
+  setModeOffSwitch(value: boolean): ServiceResult {
+    if (!value) {
+      return { success: false, reason: 'a mode switch can only be turned on' };
+    }
+    return this.stateHandler.updateTargetState(SecurityState.OFF, OriginType.INTERNAL, 0);
+  }
+
+  setModeAwayExtendedSwitch(value: boolean): ServiceResult {
+    if (!value) {
+      return { success: false, reason: 'the away-extended switch can only be turned on' };
+    }
+    const delay = this.stateHandler.getArmingSeconds(SecurityState.AWAY);
+    const result = this.stateHandler.updateTargetState(SecurityState.AWAY, OriginType.INTERNAL, delay);
+    if (result.success) {
+      this.state.modeAwayExtended = true;
+    }
+    return result;
+  }
+
+  setModePauseSwitch(value: boolean): ServiceResult {
+    if (this.state.currentState === SecurityState.TRIGGERED) {
+      this.log.warn('Mode pause (Alarm is triggered)');
+      return { success: false, reason: 'mode pause is not allowed while the alarm is triggered' };
+    }
+
+    if (value) {
+      if (this.state.currentState === SecurityState.OFF) {
+        this.log.warn('Mode pause (Not armed)');
+        return { success: false, reason: 'mode pause is not allowed while disarmed' };
+      }
+
+      this.log.info('Mode pause (Started)');
+      this.state.pausedCurrentState = this.state.currentState;
+      this.stateHandler.updateTargetState(SecurityState.OFF, OriginType.INTERNAL, 0);
+
+      if (this.options.pauseMinutes !== 0) {
+        this.timers.setPauseTimer(this.options.pauseMinutes * 60 * 1000, () => {
+          this.log.info('Mode pause (Finished)');
+          const prev = this.state.pausedCurrentState ?? this.state.defaultState;
+          this.stateHandler.updateTargetState(prev, OriginType.INTERNAL, this.stateHandler.getArmingSeconds(prev));
+        });
+      }
+    } else {
+      this.log.info('Mode pause (Cancelled)');
+      this.timers.clearPauseTimer();
+
+      const prev = this.state.pausedCurrentState ?? this.state.defaultState;
+      this.stateHandler.updateTargetState(prev, OriginType.INTERNAL, this.stateHandler.getArmingSeconds(prev));
+    }
+
+    return { success: true };
+  }
+
+  // ── Arming lock switches ───────────────────────────────────────────────────
+
+  updateArmingLock(mode: string, value: boolean): ServiceResult {
+    this.logArmingLock(mode, value);
+
+    const locks = this.state.armingLocks;
+    const key: keyof typeof locks | undefined = ['global', 'home', 'away', 'night']
+      .find(candidate => candidate === mode) as keyof typeof locks | undefined;
+
+    if (!key) {
+      this.log.debug(`Unknown arming lock mode (${mode})`);
+      return { success: false, reason: `unknown arming lock mode: ${mode}` };
+    }
+
+    locks[key] = value;
+    return { success: true };
+  }
+
+  private logArmingLock(mode: string, value: boolean): void {
+    this.log.info(`Arming lock [${capitalise(mode)}] (${value ? 'On' : 'Off'})`);
+  }
+}

package/src/handlers/trip-handler.ts

@@ -0,0 +1,193 @@
+import type { Logging } from 'homebridge';
+import { SecurityState } from '../types/security-state-type.js';
+import { OriginType } from '../types/origin-type.js';
+import type { SystemState } from '../interfaces/system-state-interface.js';
+import type { SecuritySystemOptions } from '../interfaces/options-interface.js';
+import type { EventBusService } from '../services/event-bus-service.js';
+import { EventType } from '../types/event-type.js';
+import type { SensorHandler } from './sensor-handler.js';
+import type { Condition } from '../conditions/condition.js';
+import type { ConditionContext } from '../interfaces/condition-context-interface.js';
+import { NotArmedCondition } from '../conditions/not-armed-condition.js';
+import { ArmingInProgressCondition } from '../conditions/arming-in-progress-condition.js';
+import { AlreadyTriggeredCondition } from '../conditions/already-triggered-condition.js';
+import { DoubleKnockCondition } from '../conditions/double-knock-condition.js';
+import { TriggerAlreadyRunningCondition } from '../conditions/trigger-already-running-condition.js';
+import type { TimerManager } from '../timers/timer-manager.js';
+import type { ServiceResult } from '../types/service-result-type.js';
+
+/**
+ * Handles the trip switch and trigger-delay logic, including all blocking conditions.
+ * Communicates state transitions back to the state machine via the event bus so that
+ * no circular import is needed with StateHandler.
+ */
+export class TripHandler {
+  private readonly conditions: readonly Condition[];
+
+  constructor(
+    private readonly state: SystemState,
+    private readonly options: SecuritySystemOptions,
+    private readonly log: Logging,
+    private readonly bus: EventBusService,
+    private readonly sensorHandler: SensorHandler,
+    private readonly timers: TimerManager,
+  ) {
+    const doubleKnock = new DoubleKnockCondition(
+      (seconds, onExpire) => {
+        this.timers.setDoubleKnockTimer(seconds * 1000, onExpire);
+      },
+      () => {
+        this.timers.clearDoubleKnockTimer();
+      },
+    );
+
+    this.conditions = [
+      new NotArmedCondition(),
+      new ArmingInProgressCondition(),
+      doubleKnock,
+      new AlreadyTriggeredCondition(),
+      new TriggerAlreadyRunningCondition(),
+    ];
+  }
+
+  /**
+   * Evaluates all blocking conditions for a trip action without side effects.
+   * Returns a failed result with the condition's reason if any condition blocks the action.
+   */
+  checkTripConditions(value: boolean, origin: OriginType): ServiceResult {
+    if (!value) {
+      return { success: true };
+    }
+
+    const ctx = this.makeContext(value, origin);
+    for (const condition of this.conditions) {
+      if (condition.evaluate(ctx)) {
+        return { success: false, reason: condition.failureReason };
+      }
+    }
+
+    return { success: true };
+  }
+
+  /**
+   * Core trip-switch logic shared by all trip/trigger paths.
+   * Returns a result object indicating success or the reason for failure.
+   */
+  updateTripSwitch(value: boolean, origin: OriginType, stateChanged: boolean): ServiceResult {
+    if (value) {
+      const conditionResult = this.checkTripConditions(value, origin);
+      if (!conditionResult.success) {
+        return conditionResult;
+      }
+
+      this.activateTrip(origin);
+    } else {
+      this.cancelTrip(origin, stateChanged);
+    }
+
+    // Sync trip switch characteristic when origin is not a direct switch press.
+    return { success: true };
+  }
+
+  /**
+   * Trip a mode-specific switch. Only triggers if the system is currently in
+   * the required mode (or the alarm is triggered and target matches).
+   */
+  triggerIfModeSet(requiredState: SecurityState, value: boolean): ServiceResult {
+    const isTriggered = this.state.currentState === SecurityState.TRIGGERED;
+
+    if (value) {
+      const modeMatches = this.state.currentState === requiredState
+        || (isTriggered && this.state.targetState === requiredState);
+
+      if (!modeMatches) {
+        this.log.debug('Security System (Trip mode not set)');
+        return { success: false, reason: 'mode not set' };
+      }
+    }
+
+    return this.updateTripSwitch(value, OriginType.REGULAR_SWITCH, false);
+  }
+
+  private makeContext(value: boolean, origin: OriginType): ConditionContext {
+    return {
+      state: this.state,
+      options: this.options,
+      value,
+      origin,
+      log: this.log,
+    };
+  }
+
+  private activateTrip(origin: OriginType): void {
+    this.log.info('Security System (Tripped)');
+
+    if (this.options.trippedMotionSensor) {
+      this.startTrippedMotionSensor();
+    }
+
+    const triggerSeconds = this.resolveTriggerSeconds();
+    this.log.debug(`Trigger delay (${triggerSeconds}s)`);
+
+    this.state.isTripping = true;
+    this.timers.setTriggerTimer(triggerSeconds * 1000, () => {
+      this.state.isTripping = false;
+      this.bus.emit(EventType.TRIGGER_FIRED, { origin });
+    });
+
+    if (triggerSeconds > 0) {
+      this.bus.emit(EventType.WARNING, { origin, triggerSeconds });
+    }
+  }
+
+  private startTrippedMotionSensor(): void {
+    const seconds = this.options.trippedMotionSensorSeconds;
+    if (seconds === 0) {
+      this.sensorHandler.setTrippedMotionSensor(true);
+    } else {
+      this.sensorHandler.pulseTrippedMotionSensor();
+      this.timers.setTrippedInterval(
+        seconds * 1000,
+        () => this.sensorHandler.pulseTrippedMotionSensor(),
+      );
+    }
+  }
+
+  private cancelTrip(origin: OriginType, stateChanged: boolean): void {
+    this.log.info('Security System (Cancelled)');
+    this.state.isTripping = false;
+
+    this.bus.emit(EventType.TRIP_CANCELLED, { origin, stateChanged });
+
+    if (this.options.trippedMotionSensor) {
+      this.sensorHandler.resetTrippedMotionSensor();
+    }
+
+    this.state.isKnocked = false;
+  }
+
+  private resolveTriggerSeconds(): number {
+    const seconds = this.options.triggerSeconds;
+    const cur = this.state.currentState;
+
+    if (cur === SecurityState.HOME && this.options.homeTriggerSeconds !== null) {
+      return this.options.homeTriggerSeconds;
+    }
+
+    if (cur === SecurityState.AWAY) {
+      if (this.options.modeAwayExtendedSwitchTriggerSeconds !== null && this.state.modeAwayExtended) {
+        return this.options.modeAwayExtendedSwitchTriggerSeconds;
+      }
+
+      if (this.options.awayTriggerSeconds !== null) {
+        return this.options.awayTriggerSeconds;
+      }
+    }
+
+    if (cur === SecurityState.NIGHT && this.options.nightTriggerSeconds !== null) {
+      return this.options.nightTriggerSeconds;
+    }
+
+    return seconds;
+  }
+}

package/src/homekit/homekit-registrar.ts

@@ -0,0 +1,28 @@
+import type { CharacteristicValue } from 'homebridge';
+import type { CharacteristicConstructor } from '../interfaces/hap-types-interface.js';
+import type { ServiceRegistry } from '../interfaces/service-registry-interface.js';
+import type { SystemState } from '../interfaces/system-state-interface.js';
+import { SecurityState } from '../types/security-state-type.js';
+import { OriginType } from '../types/origin-type.js';
+import type { StateHandler } from '../handlers/state-handler.js';
+
+/** Attaches the HomeKit characteristic handlers (onGet / onSet) to the security system service. */
+export class HomeKitRegistrar {
+  constructor(
+    private readonly svcs: ServiceRegistry,
+    private readonly state: SystemState,
+    private readonly stateHandler: StateHandler,
+  ) {}
+
+  register(Char: CharacteristicConstructor): void {
+    const s = this.svcs;
+
+    s.mainService.getCharacteristic(Char.SecuritySystemCurrentState)
+      .onGet(async (): Promise<CharacteristicValue> => this.state.currentState);
+    s.mainService.getCharacteristic(Char.SecuritySystemTargetState)
+      .onGet(async (): Promise<CharacteristicValue> => this.state.targetState)
+      .onSet(async (v: CharacteristicValue) => {
+        this.stateHandler.updateTargetState(v as SecurityState, OriginType.REGULAR_SWITCH, this.stateHandler.getArmingSeconds(v as SecurityState));
+      });
+  }
+}

package/src/homekit/service-factory.ts

@@ -0,0 +1,35 @@
+import type { Service } from 'homebridge';
+import type { CharacteristicConstructor } from '../interfaces/hap-types-interface.js';
+import type { SecuritySystemOptions } from '../interfaces/options-interface.js';
+import type { ServiceRegistry } from '../interfaces/service-registry-interface.js';
+
+/**
+ * Creates the HomeKit services for the accessory. Switches and motion sensors
+ * are published over Matter only, so the HomeKit accessory only carries the
+ * security system service and its accessory information service.
+ */
+export function buildServiceRegistry(
+  Svc: typeof Service,
+  Char: CharacteristicConstructor,
+  options: SecuritySystemOptions,
+): ServiceRegistry {
+  const mainSvc = new Svc.SecuritySystem(options.name);
+  mainSvc.addCharacteristic(Char.ConfiguredName);
+
+  const infoSvc = new Svc.AccessoryInformation();
+  infoSvc.setCharacteristic(Char.Name, options.name);
+  infoSvc.setCharacteristic(Char.Identify, true);
+  infoSvc.setCharacteristic(Char.Manufacturer, 'MiguelRipoll23');
+  infoSvc.setCharacteristic(Char.Model, 'DIY');
+  infoSvc.setCharacteristic(Char.SerialNumber, options.serialNumber);
+
+  return {
+    mainService: mainSvc,
+    accessoryInfoService: infoSvc,
+  };
+}
+
+/** Builds the list of services to expose to HomeKit. */
+export function buildServiceList(svcs: ServiceRegistry): Service[] {
+  return [svcs.mainService, svcs.accessoryInfoService];
+}

package/src/index.ts

@@ -0,0 +1,9 @@
+import type { API } from 'homebridge';
+import { SecuritySystemPlatform } from './security-system-platform.js';
+
+const PLUGIN_NAME = 'homebridge-securitysystem';
+const PLATFORM_NAME = 'security-system';
+
+export default (api: API): void => {
+  api.registerPlatform(PLUGIN_NAME, PLATFORM_NAME, SecuritySystemPlatform);
+};

package/src/interfaces/condition-context-interface.ts

@@ -0,0 +1,15 @@
+import type { Logging } from 'homebridge';
+import type { OriginType } from '../types/origin-type.js';
+import type { SecuritySystemOptions } from './options-interface.js';
+import type { SystemState } from './system-state-interface.js';
+
+/** Context passed to Condition.evaluate() to determine if an action is blocked. */
+export interface ConditionContext {
+  state: SystemState;
+  options: SecuritySystemOptions;
+  /** The value being set (true = activating, false = deactivating). */
+  value: boolean;
+  origin: OriginType;
+  /** Logger used by conditions to emit their own warning messages when blocking. */
+  log: Logging;
+}

package/src/interfaces/hap-types-interface.ts

@@ -0,0 +1,11 @@
+import type { API } from 'homebridge';
+
+/**
+ * Runtime type of `api.hap.Characteristic` (the class with all static characteristic
+ * definitions). Using `API['hap']['Characteristic']` avoids the self-referential
+ * `typeof Characteristic` issue that arises with `import type { Characteristic }`.
+ */
+export type CharacteristicConstructor = API['hap']['Characteristic'];
+
+/** Runtime type of `api.hap.Service`. */
+export type ServiceConstructor = API['hap']['Service'];

package/src/interfaces/mqtt-status-payload-interface.ts

@@ -0,0 +1,6 @@
+export interface MqttStatusPayload {
+  arming: boolean;
+  current_mode: string;
+  target_mode: string;
+  tripped: boolean;
+}