@switchbot/homebridge-switchbot 3.5.0-beta.9 → 3.5.1-beta.0

package/dist/irdevice/light.js

@@ -1,116 +1,108 @@
-import { request } from 'undici';
-import { Devices } from '../settings.js';
+/* Copyright(C) 2021-2024, donavanbecker (https://github.com/donavanbecker). All rights reserved.
+ *
+ * light.ts: @switchbot/homebridge-switchbot.
+ */
+import { irdeviceBase } from './irdevice.js';
 /**
  * Platform Accessory
  * An instance of this class is created for each accessory your platform registers
  * Each accessory may expose multiple services of different service types.
  */
-export class Light {
+export class Light extends irdeviceBase {
     platform;
-    accessory;
-    device;
-    api;
-    log;
-    config;
-    hap;
     // Services
-    lightBulbService;
-    ProgrammableSwitchServiceOn;
-    ProgrammableSwitchServiceOff;
-    // Characteristic Values
-    On;
-    ProgrammableSwitchEventOn;
-    ProgrammableSwitchOutputStateOn;
-    ProgrammableSwitchEventOff;
-    ProgrammableSwitchOutputStateOff;
-    FirmwareRevision;
-    // Config
-    deviceLogging;
-    disablePushOn;
-    disablePushOff;
+    LightBulb;
+    ProgrammableSwitchOn;
+    ProgrammableSwitchOff;
     constructor(platform, accessory, device) {
+        super(platform, accessory, device);
         this.platform = platform;
-        this.accessory = accessory;
-        this.device = device;
-        this.api = this.platform.api;
-        this.log = this.platform.log;
-        this.config = this.platform.config;
-        this.hap = this.api.hap;
-        // default placeholders
-        this.deviceLogs(device);
-        this.deviceContext();
-        this.disablePushOnChanges(device);
-        this.disablePushOffChanges(device);
-        this.deviceConfig(device);
-        // set accessory information
-        accessory
-            .getService(this.hap.Service.AccessoryInformation)
-            .setCharacteristic(this.hap.Characteristic.Manufacturer, 'SwitchBot')
-            .setCharacteristic(this.hap.Characteristic.Model, device.remoteType)
-            .setCharacteristic(this.hap.Characteristic.SerialNumber, device.deviceId)
-            .setCharacteristic(this.hap.Characteristic.FirmwareRevision, accessory.context.FirmwareRevision);
         if (!device.irlight?.stateless) {
-            // get the Light service if it exists, otherwise create a new Light service
-            // you can create multiple services for each accessory
-            const lightBulbService = `${accessory.displayName} ${device.remoteType}`;
-            (this.lightBulbService = accessory.getService(this.hap.Service.Lightbulb)
-                || accessory.addService(this.hap.Service.Lightbulb)), lightBulbService;
-            this.lightBulbService.setCharacteristic(this.hap.Characteristic.Name, accessory.displayName);
-            if (!this.lightBulbService.testCharacteristic(this.hap.Characteristic.ConfiguredName)) {
-                this.lightBulbService.addCharacteristic(this.hap.Characteristic.ConfiguredName, accessory.displayName);
-            }
-            // handle on / off events using the On characteristic
-            this.lightBulbService.getCharacteristic(this.hap.Characteristic.On).onSet(this.OnSet.bind(this));
+            // Initialize LightBulb Service
+            accessory.context.LightBulb = accessory.context.LightBulb ?? {};
+            this.LightBulb = {
+                Name: accessory.context.LightBulb.Name ?? `${accessory.displayName} ${device.remoteType}`,
+                Service: accessory.getService(this.hap.Service.Lightbulb) ?? accessory.addService(this.hap.Service.Lightbulb),
+                On: accessory.context.On || false,
+            };
+            accessory.context.LightBulb = this.LightBulb;
+            this.LightBulb.Service
+                .setCharacteristic(this.hap.Characteristic.Name, this.LightBulb.Name)
+                .getCharacteristic(this.hap.Characteristic.On)
+                .onGet(() => {
+                return this.LightBulb.On;
+            })
+                .onSet(this.OnSet.bind(this));
         }
         else {
-            // create a new Stateful Programmable Switch On service
-            const ProgrammableSwitchServiceOn = `${accessory.displayName} ${device.remoteType} On`;
-            (this.ProgrammableSwitchServiceOn = accessory.getService(this.hap.Service.StatefulProgrammableSwitch)
-                || accessory.addService(this.hap.Service.StatefulProgrammableSwitch)), ProgrammableSwitchServiceOn;
-            this.ProgrammableSwitchServiceOn.setCharacteristic(this.hap.Characteristic.Name, `${accessory.displayName} On`);
-            if (!this.ProgrammableSwitchServiceOn.testCharacteristic(this.hap.Characteristic.ConfiguredName)) {
-                this.ProgrammableSwitchServiceOn.addCharacteristic(this.hap.Characteristic.ConfiguredName, `${accessory.displayName} On`);
-            }
-            this.ProgrammableSwitchServiceOn.getCharacteristic(this.hap.Characteristic.ProgrammableSwitchEvent).setProps({
+            // Initialize ProgrammableSwitchOn Service
+            accessory.context.ProgrammableSwitchOn = accessory.context.ProgrammableSwitchOn ?? {};
+            this.ProgrammableSwitchOn = {
+                Name: accessory.context.ProgrammableSwitchOn.Name ?? `${accessory.displayName} ${device.remoteType} On`,
+                Service: accessory.getService(this.hap.Service.StatefulProgrammableSwitch)
+                    ?? accessory.addService(this.hap.Service.StatefulProgrammableSwitch),
+                ProgrammableSwitchEvent: accessory.context.ProgrammableSwitchEvent ?? this.hap.Characteristic.ProgrammableSwitchEvent.SINGLE_PRESS,
+                ProgrammableSwitchOutputState: accessory.context.ProgrammableSwitchOutputState ?? 0,
+            };
+            accessory.context.ProgrammableSwitchOn = this.ProgrammableSwitchOn;
+            // Initialize ProgrammableSwitchOn Characteristics
+            this.ProgrammableSwitchOn?.Service
+                .setCharacteristic(this.hap.Characteristic.Name, this.ProgrammableSwitchOn.Name)
+                .getCharacteristic(this.hap.Characteristic.ProgrammableSwitchEvent).setProps({
                 validValueRanges: [0, 0],
                 minValue: 0,
                 maxValue: 0,
                 validValues: [0],
             })
                 .onGet(() => {
-                return this.ProgrammableSwitchEventOn;
+                return this.ProgrammableSwitchOn.ProgrammableSwitchEvent;
             });
-            this.ProgrammableSwitchServiceOn.getCharacteristic(this.hap.Characteristic.ProgrammableSwitchOutputState)
+            this.ProgrammableSwitchOn?.Service
+                .getCharacteristic(this.hap.Characteristic.ProgrammableSwitchOutputState)
+                .onGet(() => {
+                return this.ProgrammableSwitchOn.ProgrammableSwitchOutputState;
+            })
                 .onSet(this.ProgrammableSwitchOutputStateSetOn.bind(this));
-            // create a new Stateful Programmable Switch Off service
-            const ProgrammableSwitchServiceOff = `${accessory.displayName} ${device.remoteType} Off`;
-            (this.ProgrammableSwitchServiceOff = accessory.getService(this.hap.Service.StatefulProgrammableSwitch)
-                || accessory.addService(this.hap.Service.StatefulProgrammableSwitch)), ProgrammableSwitchServiceOff;
-            this.ProgrammableSwitchServiceOff.setCharacteristic(this.hap.Characteristic.Name, `${accessory.displayName} Off`);
-            if (!this.ProgrammableSwitchServiceOff.testCharacteristic(this.hap.Characteristic.ConfiguredName)) {
-                this.ProgrammableSwitchServiceOff.addCharacteristic(this.hap.Characteristic.ConfiguredName, `${accessory.displayName} Off`);
-            }
-            this.ProgrammableSwitchServiceOff.getCharacteristic(this.hap.Characteristic.ProgrammableSwitchEvent).setProps({
+            // Initialize ProgrammableSwitchOff Service
+            accessory.context.ProgrammableSwitchOff = accessory.context.ProgrammableSwitchOff ?? {};
+            this.ProgrammableSwitchOff = {
+                Name: accessory.context.ProgrammableSwitchOff.Name ?? `${accessory.displayName} ${device.remoteType} Off`,
+                Service: accessory.getService(this.hap.Service.StatefulProgrammableSwitch)
+                    ?? accessory.addService(this.hap.Service.StatefulProgrammableSwitch),
+                ProgrammableSwitchEvent: accessory.context.ProgrammableSwitchEvent ?? this.hap.Characteristic.ProgrammableSwitchEvent.SINGLE_PRESS,
+                ProgrammableSwitchOutputState: accessory.context.ProgrammableSwitchOutputState ?? 0,
+            };
+            accessory.context.ProgrammableSwitchOff = this.ProgrammableSwitchOff;
+            // Initialize ProgrammableSwitchOff Characteristics
+            this.ProgrammableSwitchOff?.Service
+                .setCharacteristic(this.hap.Characteristic.Name, this.ProgrammableSwitchOff.Name)
+                .getCharacteristic(this.hap.Characteristic.ProgrammableSwitchEvent).setProps({
                 validValueRanges: [0, 0],
                 minValue: 0,
                 maxValue: 0,
                 validValues: [0],
             })
                 .onGet(() => {
-                return this.ProgrammableSwitchEventOff;
+                return this.ProgrammableSwitchOff.ProgrammableSwitchEvent;
             });
-            this.ProgrammableSwitchServiceOff.getCharacteristic(this.hap.Characteristic.ProgrammableSwitchOutputState)
+            this.ProgrammableSwitchOff?.Service
+                .getCharacteristic(this.hap.Characteristic.ProgrammableSwitchOutputState)
+                .onGet(() => {
+                return this.ProgrammableSwitchOff.ProgrammableSwitchOutputState;
+            })
                 .onSet(this.ProgrammableSwitchOutputStateSetOff.bind(this));
         }
     }
     async OnSet(value) {
         this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} On: ${value}`);
-        this.On = value;
-        if (this.On) {
-            await this.pushLightOnChanges();
+        this.LightBulb.On = value;
+        if (this.LightBulb?.On) {
+            const On = true;
+            await this.pushLightOnChanges(On);
         }
         else {
-            await this.pushLightOffChanges();
+            const On = false;
+            await this.pushLightOffChanges(On);
         }
         /**
          * pushLightOnChanges and pushLightOffChanges above assume they are measuring the state of the accessory BEFORE
@@ -119,10 +111,10 @@ export class Light {
     }
     async ProgrammableSwitchOutputStateSetOn(value) {
         this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} On: ${value}`);
-        this.ProgrammableSwitchOutputStateOn = value;
-        if (this.ProgrammableSwitchOutputStateOn === 1) {
-            this.On = true;
-            await this.pushLightOnChanges();
+        this.ProgrammableSwitchOn.ProgrammableSwitchOutputState = value;
+        if (this.ProgrammableSwitchOn?.ProgrammableSwitchOutputState === 1) {
+            const On = true;
+            await this.pushLightOnChanges(On);
         }
         /**
          * pushLightOnChanges and pushLightOffChanges above assume they are measuring the state of the accessory BEFORE
@@ -131,10 +123,10 @@ export class Light {
     }
     async ProgrammableSwitchOutputStateSetOff(value) {
         this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} On: ${value}`);
-        this.ProgrammableSwitchOutputStateOff = value;
-        if (this.ProgrammableSwitchOutputStateOff === 1) {
-            this.On = false;
-            await this.pushLightOffChanges();
+        this.ProgrammableSwitchOff.ProgrammableSwitchOutputState = value;
+        if (this.ProgrammableSwitchOff?.ProgrammableSwitchOutputState === 1) {
+            const On = false;
+            await this.pushLightOffChanges(On);
         }
         /**
          * pushLightOnChanges and pushLightOffChanges above assume they are measuring the state of the accessory BEFORE
@@ -151,9 +143,9 @@ export class Light {
      * Light -       "command"       "channelAdd"      "default"	        =        next channel
      * Light -       "command"       "channelSub"      "default"	        =        previous channel
      */
-    async pushLightOnChanges() {
-        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushLightOnChanges On: ${this.On},` + ` disablePushOn: ${this.disablePushOn}`);
-        if (this.On && !this.disablePushOn) {
+    async pushLightOnChanges(On) {
+        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushLightOnChanges On: ${On}, disablePushOn: ${this.disablePushOn}`);
+        if (On === true && this.disablePushOn === false) {
             const commandType = await this.commandType();
             const command = await this.commandOn();
             const bodyChange = JSON.stringify({
@@ -161,12 +153,12 @@ export class Light {
                 parameter: 'default',
                 commandType: commandType,
             });
-            await this.pushChanges(bodyChange);
+            await this.pushChanges(bodyChange, On);
         }
     }
-    async pushLightOffChanges() {
-        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushLightOffChanges On: ${this.On},` + ` disablePushOff: ${this.disablePushOff}`);
-        if (!this.On && !this.disablePushOff) {
+    async pushLightOffChanges(On) {
+        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushLightOffChanges On: ${On}, disablePushOff: ${this.disablePushOff}`);
+        if (On === false && this.disablePushOff === false) {
             const commandType = await this.commandType();
             const command = await this.commandOff();
             const bodyChange = JSON.stringify({
@@ -174,332 +166,85 @@ export class Light {
                 parameter: 'default',
                 commandType: commandType,
             });
-            await this.pushChanges(bodyChange);
+            await this.pushChanges(bodyChange, On);
         }
     }
-    /*async pushLightBrightnessUpChanges(): Promise<void> {
-      const bodyChange = JSON.stringify({
-        command: 'brightnessUp',
-        parameter: 'default',
-        commandType: 'command',
-      });
-      await this.pushChanges(bodyChange);
-    }
-  
-    async pushLightBrightnessDownChanges(): Promise<void> {
-      const bodyChange = JSON.stringify({
-        command: 'brightnessDown',
-        parameter: 'default',
-        commandType: 'command',
-      });
-      await this.pushChanges(bodyChange);
-    }*/
-    async pushChanges(bodyChange) {
+    async pushChanges(bodyChange, On) {
         this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushChanges`);
         if (this.device.connectionType === 'OpenAPI') {
             this.infoLog(`${this.device.remoteType}: ${this.accessory.displayName} Sending request to SwitchBot API, body: ${bodyChange},`);
             try {
-                const { body, statusCode } = await request(`${Devices}/${this.device.deviceId}/commands`, {
-                    body: bodyChange,
-                    method: 'POST',
-                    headers: this.platform.generateHeaders(),
-                });
-                this.debugWarnLog(`${this.device.remoteType}: ${this.accessory.displayName} statusCode: ${statusCode}`);
+                const { body, statusCode } = await this.pushChangeRequest(bodyChange);
                 const deviceStatus = await body.json();
-                this.debugWarnLog(`${this.device.remoteType}: ${this.accessory.displayName} deviceStatus: ${JSON.stringify(deviceStatus)}`);
-                this.debugWarnLog(`${this.device.remoteType}: ${this.accessory.displayName} deviceStatus statusCode: ${deviceStatus.statusCode}`);
+                await this.pushStatusCodes(statusCode, deviceStatus);
                 if ((statusCode === 200 || statusCode === 100) && (deviceStatus.statusCode === 200 || deviceStatus.statusCode === 100)) {
-                    this.debugErrorLog(`${this.device.remoteType}: ${this.accessory.displayName} `
-                        + `statusCode: ${statusCode} & deviceStatus StatusCode: ${deviceStatus.statusCode}`);
-                    this.accessory.context.On = this.On;
-                    this.updateHomeKitCharacteristics();
+                    await this.successfulPushChange(statusCode, deviceStatus, bodyChange);
+                    this.accessory.context.On = On;
+                    await this.updateHomeKitCharacteristics();
                 }
                 else {
-                    this.statusCode(statusCode);
-                    this.statusCode(deviceStatus.statusCode);
+                    await this.statusCode(statusCode);
+                    await this.statusCode(deviceStatus.statusCode);
                 }
             }
             catch (e) {
                 this.apiError(e);
-                this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} failed pushChanges with ${this.device.connectionType}` +
-                    ` Connection, Error Message: ${JSON.stringify(e.message)}`);
+                this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} failed pushChanges with ${this.device.connectionType}`
+                    + ` Connection, Error Message: ${JSON.stringify(e.message)}`);
             }
         }
         else {
-            this.warnLog(`${this.device.remoteType}: ${this.accessory.displayName}` +
-                ` Connection Type: ${this.device.connectionType}, commands will not be sent to OpenAPI`);
+            this.warnLog(`${this.device.remoteType}: ${this.accessory.displayName} Connection Type: `
+                + `${this.device.connectionType}, commands will not be sent to OpenAPI`);
         }
     }
     async updateHomeKitCharacteristics() {
-        if (this.device.irlight?.stateless) {
+        if (!this.device.irlight?.stateless) {
             // On
-            if (this.On === undefined) {
-                this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} On: ${this.On}`);
+            if (this.LightBulb?.On === undefined) {
+                this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} On: ${this.LightBulb?.On}`);
             }
             else {
-                this.accessory.context.On = this.On;
-                this.lightBulbService?.updateCharacteristic(this.hap.Characteristic.On, this.On);
-                this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic On: ${this.On}`);
+                this.accessory.context.On = this.LightBulb.On;
+                this.LightBulb?.Service.updateCharacteristic(this.hap.Characteristic.On, this.LightBulb.On);
+                this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic On: ${this.LightBulb.On}`);
             }
         }
         else {
             // On Stateful Programmable Switch
-            if (this.ProgrammableSwitchOutputStateOn === undefined) {
+            if (this.ProgrammableSwitchOn?.ProgrammableSwitchOutputState === undefined) {
                 this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName}`
-                    + ` ProgrammableSwitchOutputStateOn: ${this.ProgrammableSwitchOutputStateOn}`);
+                    + ` ProgrammableSwitchOutputStateOn: ${this.ProgrammableSwitchOn?.ProgrammableSwitchOutputState}`);
             }
             else {
-                this.accessory.context.ProgrammableSwitchOutputStateOn = this.ProgrammableSwitchOutputStateOn;
-                this.ProgrammableSwitchServiceOn?.updateCharacteristic(this.hap.Characteristic.ProgrammableSwitchOutputState, this.ProgrammableSwitchOutputStateOn);
+                this.accessory.context.ProgrammableSwitchOutputStateOn = this.ProgrammableSwitchOn.ProgrammableSwitchOutputState;
+                this.ProgrammableSwitchOn?.Service.updateCharacteristic(this.hap.Characteristic.ProgrammableSwitchOutputState, this.ProgrammableSwitchOn.ProgrammableSwitchOutputState);
                 this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic`
-                    + ` ProgrammableSwitchOutputStateOn: ${this.ProgrammableSwitchOutputStateOn}`);
+                    + ` ProgrammableSwitchOutputStateOn: ${this.ProgrammableSwitchOn.ProgrammableSwitchOutputState}`);
             }
             // Off Stateful Programmable Switch
-            if (this.ProgrammableSwitchOutputStateOff === undefined) {
+            if (this.ProgrammableSwitchOff?.ProgrammableSwitchOutputState === undefined) {
                 this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName}`
-                    + ` ProgrammableSwitchOutputStateOff: ${this.ProgrammableSwitchOutputStateOff}`);
+                    + ` ProgrammableSwitchOutputStateOff: ${this.ProgrammableSwitchOff?.ProgrammableSwitchOutputState}`);
             }
             else {
-                this.accessory.context.ProgrammableSwitchOutputStateOff = this.ProgrammableSwitchOutputStateOff;
-                this.ProgrammableSwitchServiceOff?.updateCharacteristic(this.hap.Characteristic.ProgrammableSwitchOutputState, this.ProgrammableSwitchOutputStateOff);
+                this.accessory.context.ProgrammableSwitchOutputStateOff = this.ProgrammableSwitchOff.ProgrammableSwitchOutputState;
+                this.ProgrammableSwitchOff.Service.updateCharacteristic(this.hap.Characteristic.ProgrammableSwitchOutputState, this.ProgrammableSwitchOff.ProgrammableSwitchOutputState);
                 this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic`
-                    + ` ProgrammableSwitchOutputStateOff: ${this.ProgrammableSwitchOutputStateOff}`);
+                    + ` ProgrammableSwitchOutputStateOff: ${this.ProgrammableSwitchOff?.ProgrammableSwitchOutputState}`);
             }
         }
     }
-    async disablePushOnChanges(device) {
-        if (device.disablePushOn === undefined) {
-            this.disablePushOn = false;
-        }
-        else {
-            this.disablePushOn = device.disablePushOn;
-        }
-    }
-    async disablePushOffChanges(device) {
-        if (device.disablePushOff === undefined) {
-            this.disablePushOff = false;
-        }
-        else {
-            this.disablePushOff = device.disablePushOff;
-        }
-    }
-    async commandType() {
-        let commandType;
-        if (this.device.customize) {
-            commandType = 'customize';
-        }
-        else {
-            commandType = 'command';
-        }
-        return commandType;
-    }
-    async commandOn() {
-        let command;
-        if (this.device.customize && this.device.customOn) {
-            command = this.device.customOn;
-        }
-        else {
-            command = 'turnOn';
-        }
-        return command;
-    }
-    async commandOff() {
-        let command;
-        if (this.device.customize && this.device.customOff) {
-            command = this.device.customOff;
-        }
-        else {
-            command = 'turnOff';
-        }
-        return command;
-    }
-    async statusCode(statusCode) {
-        switch (statusCode) {
-            case 151:
-                this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Command not supported by this deviceType, statusCode: ${statusCode}`);
-                break;
-            case 152:
-                this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Device not found, statusCode: ${statusCode}`);
-                break;
-            case 160:
-                this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Command is not supported, statusCode: ${statusCode}`);
-                break;
-            case 161:
-                this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Device is offline, statusCode: ${statusCode}`);
-                break;
-            case 171:
-                this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Hub Device is offline, statusCode: ${statusCode}. ` +
-                    `Hub: ${this.device.hubDeviceId}`);
-                break;
-            case 190:
-                this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Device internal error due to device states not synchronized with server,` +
-                    ` Or command format is invalid, statusCode: ${statusCode}`);
-                break;
-            case 100:
-                this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Command successfully sent, statusCode: ${statusCode}`);
-                break;
-            case 200:
-                this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Request successful, statusCode: ${statusCode}`);
-                break;
-            case 400:
-                this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Bad Request, The client has issued an invalid request. `
-                    + `This is commonly used to specify validation errors in a request payload, statusCode: ${statusCode}`);
-                break;
-            case 401:
-                this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Unauthorized,	Authorization for the API is required, `
-                    + `but the request has not been authenticated, statusCode: ${statusCode}`);
-                break;
-            case 403:
-                this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Forbidden,	The request has been authenticated but does not `
-                    + `have appropriate permissions, or a requested resource is not found, statusCode: ${statusCode}`);
-                break;
-            case 404:
-                this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Not Found,	Specifies the requested path does not exist, `
-                    + `statusCode: ${statusCode}`);
-                break;
-            case 406:
-                this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Not Acceptable,	The client has requested a MIME type via `
-                    + `the Accept header for a value not supported by the server, statusCode: ${statusCode}`);
-                break;
-            case 415:
-                this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Unsupported Media Type,	The client has defined a contentType `
-                    + `header that is not supported by the server, statusCode: ${statusCode}`);
-                break;
-            case 422:
-                this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Unprocessable Entity,	The client has made a valid request, but `
-                    + `the server cannot process it. This is often used for APIs for which certain limits have been exceeded, statusCode: ${statusCode}`);
-                break;
-            case 429:
-                this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Too Many Requests,	The client has exceeded the number of `
-                    + `requests allowed for a given time window, statusCode: ${statusCode}`);
-                break;
-            case 500:
-                this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Internal Server Error,	An unexpected error on the SmartThings `
-                    + `servers has occurred. These errors should be rare, statusCode: ${statusCode}`);
-                break;
-            default:
-                this.infoLog(`${this.device.remoteType}: ${this.accessory.displayName} Unknown statusCode: ` +
-                    `${statusCode}, Submit Bugs Here: ' + 'https://tinyurl.com/SwitchBotBug`);
-        }
-    }
     async apiError(e) {
-        if (this.device.irlight?.stateless) {
-            this.lightBulbService?.updateCharacteristic(this.hap.Characteristic.On, e);
+        if (!this.device.irlight?.stateless) {
+            this.LightBulb?.Service.updateCharacteristic(this.hap.Characteristic.On, e);
         }
         else {
-            this.ProgrammableSwitchServiceOn?.updateCharacteristic(this.hap.Characteristic.ProgrammableSwitchEvent, e);
-            this.ProgrammableSwitchServiceOn?.updateCharacteristic(this.hap.Characteristic.ProgrammableSwitchOutputState, e);
-            this.ProgrammableSwitchServiceOff?.updateCharacteristic(this.hap.Characteristic.ProgrammableSwitchEvent, e);
-            this.ProgrammableSwitchServiceOff?.updateCharacteristic(this.hap.Characteristic.ProgrammableSwitchOutputState, e);
-        }
-    }
-    async deviceContext() {
-        if (this.On === undefined) {
-            this.On = false;
-        }
-        else {
-            this.On = this.accessory.context.On;
-        }
-        if (this.FirmwareRevision === undefined) {
-            this.FirmwareRevision = this.platform.version;
-            this.accessory.context.FirmwareRevision = this.FirmwareRevision;
+            this.ProgrammableSwitchOn?.Service.updateCharacteristic(this.hap.Characteristic.ProgrammableSwitchEvent, e);
+            this.ProgrammableSwitchOn?.Service.updateCharacteristic(this.hap.Characteristic.ProgrammableSwitchOutputState, e);
+            this.ProgrammableSwitchOff?.Service.updateCharacteristic(this.hap.Characteristic.ProgrammableSwitchEvent, e);
+            this.ProgrammableSwitchOff?.Service.updateCharacteristic(this.hap.Characteristic.ProgrammableSwitchOutputState, e);
         }
     }
-    async deviceConfig(device) {
-        let config = {};
-        if (device.irlight) {
-            config = device.irlight;
-        }
-        if (device.logging !== undefined) {
-            config['logging'] = device.logging;
-        }
-        if (device.connectionType !== undefined) {
-            config['connectionType'] = device.connectionType;
-        }
-        if (device.external !== undefined) {
-            config['external'] = device.external;
-        }
-        if (device.customOn !== undefined) {
-            config['customOn'] = device.customOn;
-        }
-        if (device.customOff !== undefined) {
-            config['customOff'] = device.customOff;
-        }
-        if (device.customize !== undefined) {
-            config['customize'] = device.customize;
-        }
-        if (device.disablePushOn !== undefined) {
-            config['disablePushOn'] = device.disablePushOn;
-        }
-        if (device.disablePushOff !== undefined) {
-            config['disablePushOff'] = device.disablePushOff;
-        }
-        if (Object.entries(config).length !== 0) {
-            this.debugWarnLog(`${this.device.remoteType}: ${this.accessory.displayName} Config: ${JSON.stringify(config)}`);
-        }
-    }
-    async deviceLogs(device) {
-        if (this.platform.debugMode) {
-            this.deviceLogging = this.accessory.context.logging = 'debugMode';
-            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Using Debug Mode Logging: ${this.deviceLogging}`);
-        }
-        else if (device.logging) {
-            this.deviceLogging = this.accessory.context.logging = device.logging;
-            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Using Device Config Logging: ${this.deviceLogging}`);
-        }
-        else if (this.platform.config.options?.logging) {
-            this.deviceLogging = this.accessory.context.logging = this.platform.config.options?.logging;
-            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Using Platform Config Logging: ${this.deviceLogging}`);
-        }
-        else {
-            this.deviceLogging = this.accessory.context.logging = 'standard';
-            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Logging Not Set, Using: ${this.deviceLogging}`);
-        }
-    }
-    /**
-     * Logging for Device
-     */
-    infoLog(...log) {
-        if (this.enablingDeviceLogging()) {
-            this.platform.log.info(String(...log));
-        }
-    }
-    warnLog(...log) {
-        if (this.enablingDeviceLogging()) {
-            this.platform.log.warn(String(...log));
-        }
-    }
-    debugWarnLog(...log) {
-        if (this.enablingDeviceLogging()) {
-            if (this.deviceLogging?.includes('debug')) {
-                this.platform.log.warn('[DEBUG]', String(...log));
-            }
-        }
-    }
-    errorLog(...log) {
-        if (this.enablingDeviceLogging()) {
-            this.platform.log.error(String(...log));
-        }
-    }
-    debugErrorLog(...log) {
-        if (this.enablingDeviceLogging()) {
-            if (this.deviceLogging?.includes('debug')) {
-                this.platform.log.error('[DEBUG]', String(...log));
-            }
-        }
-    }
-    debugLog(...log) {
-        if (this.enablingDeviceLogging()) {
-            if (this.deviceLogging === 'debug') {
-                this.platform.log.info('[DEBUG]', String(...log));
-            }
-            else {
-                this.platform.log.debug(String(...log));
-            }
-        }
-    }
-    enablingDeviceLogging() {
-        return this.deviceLogging.includes('debug') || this.deviceLogging === 'standard';
-    }
 }
 //# sourceMappingURL=light.js.map