@switchbot/homebridge-switchbot 5.0.0-beta.12 → 5.0.0-beta.121

package/dist/platform.js

@@ -0,0 +1,1553 @@
+import { createDevice } from './deviceFactory.js';
+import { PLATFORM_NAME, PLUGIN_NAME } from './settings.js';
+import { SwitchBotClient } from './switchbotClient.js';
+// Which device types should prefer Matter if available
+// Based on HAP service mappings: device implementations use specific HomeKit services
+// that map to corresponding Matter clusters when Matter is enabled
+const DEVICE_MATTER_SUPPORTED = {
+    // Core devices
+    'bot': true, // Switch → OnOff
+    'curtain': true, // WindowCovering → WindowCovering
+    'fan': true, // Fan → FanControl
+    'light': true, // Lightbulb → OnOff + LevelControl
+    'lightstrip': true, // Lightbulb (color) → OnOff + LevelControl + ColorControl
+    'motion': true, // MotionSensor → OccupancySensing
+    'contact': true, // ContactSensor → BooleanState
+    'vacuum': true, // Switch → RobotVacuumCleaner
+    'lock': true, // LockMechanism → DoorLock
+    'humidifier': true, // Fan + Humidity → OnOff + FanControl + RelativeHumidityMeasurement
+    'temperature': true, // TemperatureSensor → TemperatureMeasurement
+    // Switch devices
+    'relay': true, // Switch → OnOff
+    'relay switch 1': true, // Switch → OnOff
+    'relay switch 1pm': true, // Switch → OnOff
+    'plug': true, // Outlet → OnOff
+    'plug mini (jp)': true, // Outlet → OnOff
+    'plug mini (us)': true, // Outlet → OnOff
+    // Window covering variants
+    'blindtilt': true, // WindowCovering → WindowCovering
+    'blind tilt': true, // WindowCovering → WindowCovering
+    'curtain3': true, // WindowCovering → WindowCovering
+    'rollershade': true, // WindowCovering → WindowCovering
+    'roller shade': true, // WindowCovering → WindowCovering
+    'worollershade': true, // WindowCovering → WindowCovering
+    'wo rollershade': true, // WindowCovering → WindowCovering
+    // Vacuum variants (normalized to 'vacuum' before lookup)
+    'wosweeper': true, // VacuumDevice → RobotVacuumCleaner
+    'wosweepermini': true, // VacuumDevice → RobotVacuumCleaner
+    'wosweeperminipro': true, // VacuumDevice → RobotVacuumCleaner
+    'k10+': true, // VacuumDevice → RobotVacuumCleaner
+    'k10+ pro': true, // VacuumDevice → RobotVacuumCleaner
+    // Sensors
+    'meter': true, // TemperatureSensor + HumiditySensor → TemperatureMeasurement + RelativeHumidityMeasurement
+    'meterplus': true, // TemperatureSensor + HumiditySensor → TemperatureMeasurement + RelativeHumidityMeasurement
+    'meter plus (jp)': true, // TemperatureSensor + HumiditySensor → TemperatureMeasurement + RelativeHumidityMeasurement
+    'meterpro': true, // TemperatureSensor + HumiditySensor → TemperatureMeasurement + RelativeHumidityMeasurement
+    'meterpro(co2)': true, // TemperatureSensor + HumiditySensor → TemperatureMeasurement + RelativeHumidityMeasurement
+    'waterdetector': true, // LeakSensor → BooleanState
+    'water detector': true, // LeakSensor → BooleanState
+    // Other devices
+    'smart fan': true, // Fan → FanControl
+    'strip light': true, // Lightbulb (color) → OnOff + LevelControl + ColorControl
+    'hub 2': false, // Hub device - not exposed as accessory
+    'walletfinder': false, // Button device - Matter support TBD
+};
+// Default Matter cluster configurations by device type
+// Maps device types to their Matter cluster states (used when device doesn't provide clusters)
+// Note: wosweeper/curtain/plug variants are normalized before cluster lookup (see loadDevices)
+export const DEVICE_MATTER_CLUSTERS = {
+    // Core devices - aligned with HAP service implementations
+    bot: { onOff: { onOff: false } }, // Switch → OnOff
+    vacuum: {
+        rvcRunMode: {
+            supportedModes: [
+                { label: 'Idle', mode: 0, modeTags: [{ value: 16384 }] },
+                { label: 'Cleaning', mode: 1, modeTags: [{ value: 16385 }] },
+            ],
+            currentMode: 0,
+        },
+        rvcCleanMode: {
+            supportedModes: [
+                { label: 'Vacuum', mode: 0, modeTags: [{ value: 16385 }] },
+            ],
+            currentMode: 0,
+        },
+        rvcOperationalState: {
+            operationalStateList: [
+                { operationalStateId: 0 }, // Stopped
+                { operationalStateId: 1 }, // Running
+                { operationalStateId: 2 }, // Paused
+                { operationalStateId: 3 }, // Error (required)
+                { operationalStateId: 64 }, // Seeking charger
+                { operationalStateId: 65 }, // Charging
+                { operationalStateId: 66 }, // Docked
+            ],
+            operationalState: 66,
+        },
+    }, // Switch in HAP, RobotVacuumCleaner in Matter
+    curtain: {
+        windowCovering: {
+            type: 0, // RollerShade (default for standard lift-only curtains)
+        },
+    }, // WindowCovering → WindowCovering (includes curtain3, rollershade variants via normalization)
+    blindtilt: {
+        windowCovering: {
+            type: 8, // TiltBlindLiftAndTilt - supports tilt feature
+        },
+    }, // WindowCovering with tilt → WindowCovering
+    fan: {
+        onOff: { onOff: false },
+        fanControl: {
+            fanMode: 0,
+            percentCurrent: 0,
+            percentSetting: 0,
+            speedCurrent: 0,
+            speedMax: 100,
+        },
+    }, // Fan → OnOff + FanControl
+    light: {
+        onOff: { onOff: false },
+        levelControl: {
+            currentLevel: 0,
+            minLevel: 0,
+            maxLevel: 254,
+        },
+    }, // Lightbulb → OnOff + LevelControl
+    lightstrip: {
+        onOff: { onOff: false },
+        levelControl: {
+            currentLevel: 0,
+            minLevel: 0,
+            maxLevel: 254,
+        },
+        colorControl: {
+            colorMode: 0,
+        },
+    }, // Lightbulb with color → OnOff + LevelControl + ColorControl
+    lock: {
+        doorLock: {
+            lockState: 0,
+            lockType: 0,
+            actuatorEnabled: true,
+            operatingMode: 0,
+        },
+    }, // LockMechanism → DoorLock
+    motion: {
+        occupancySensing: {
+            occupancy: 0,
+            occupancySensorType: 0,
+        },
+    }, // MotionSensor → OccupancySensing
+    contact: {
+        booleanState: {
+            stateValue: false,
+        },
+    }, // ContactSensor → BooleanState
+    humidifier: {
+        onOff: { onOff: false },
+        fanControl: {
+            fanMode: 0,
+            percentCurrent: 0,
+        },
+        relativeHumidityMeasurement: {
+            measuredValue: 0,
+            minMeasuredValue: 0,
+            maxMeasuredValue: 100,
+        },
+    }, // HumidifierDehumidifier → OnOff + FanControl + RelativeHumidityMeasurement
+    temperature: {
+        temperatureMeasurement: {
+            measuredValue: 0,
+            minMeasuredValue: -27315,
+            maxMeasuredValue: 32767,
+        },
+    }, // TemperatureSensor → TemperatureMeasurement
+    // Switch/Outlet devices
+    relay: { onOff: { onOff: false } }, // Switch → OnOff
+    plug: {
+        onOff: { onOff: false },
+        electricalMeasurement: {
+            activePower: 0,
+            rmsCurrent: 0,
+            rmsVoltage: 0,
+        },
+    }, // Outlet → OnOff + ElectricalMeasurement (for PM models)
+    // Sensors
+    meter: {
+        temperatureMeasurement: {
+            measuredValue: 0,
+            minMeasuredValue: -27315,
+            maxMeasuredValue: 32767,
+        },
+        relativeHumidityMeasurement: {
+            measuredValue: 0,
+            minMeasuredValue: 0,
+            maxMeasuredValue: 100,
+        },
+    }, // TemperatureSensor + HumiditySensor → TemperatureMeasurement + RelativeHumidityMeasurement
+    waterdetector: {
+        booleanState: {
+            stateValue: false,
+        },
+    }, // LeakSensor → BooleanState
+};
+const DEVICE_MATTER_DEVICE_TYPE_KEYS = {
+    bot: 'OnOffSwitch',
+    vacuum: 'RoboticVacuumCleaner',
+    curtain: 'WindowCovering',
+    blindtilt: 'WindowCovering',
+    fan: 'Fan',
+    light: 'DimmableLight',
+    lightstrip: 'ExtendedColorLight',
+    lock: 'DoorLock',
+    motion: 'MotionSensor',
+    contact: 'ContactSensor',
+    humidifier: 'Fan',
+    temperature: 'TemperatureSensor',
+    relay: 'OnOffSwitch',
+    plug: 'OnOffOutlet',
+    meter: 'TemperatureSensor',
+    waterdetector: 'LeakSensor',
+};
+function normalizeTypeForMatter(typeValue) {
+    const raw = String(typeValue || '').trim().toLowerCase();
+    if (!raw) {
+        return 'unknown';
+    }
+    // Vacuum variants
+    if (['wosweeper', 'wosweepermini', 'wosweeperminipro', 'k10+', 'k10+ pro'].includes(raw)) {
+        return 'vacuum';
+    }
+    // Window covering variants
+    if (['blindtilt', 'blind tilt', 'curtain3', 'rollershade', 'roller shade', 'worollershade', 'wo rollershade'].includes(raw)) {
+        return 'curtain';
+    }
+    // Plug variants
+    if (['plug mini (jp)', 'plug mini (us)', 'plug mini (eu)'].includes(raw)) {
+        return 'plug';
+    }
+    // Meter variants
+    if (['meterplus', 'meter plus', 'meter plus (jp)', 'meterpro', 'meter pro', 'meterpro(co2)', 'meter pro (co2)'].includes(raw)) {
+        return 'meter';
+    }
+    // Relay switch variants
+    if (['relay switch 1', 'relay switch 1pm'].includes(raw)) {
+        return 'relay';
+    }
+    // Water detector variants
+    if (['water detector', 'waterdetector'].includes(raw)) {
+        return 'waterdetector';
+    }
+    // Fan variants
+    if (['smart fan', 'circulator fan', 'battery circulator fan', 'standing circulator fan'].includes(raw)) {
+        return 'fan';
+    }
+    // Light variants
+    if (['strip light', 'strip light 3', 'rgbic neon rope light', 'rgbic neon wire rope light', 'rgbicww floor lamp', 'rgbicww strip light'].includes(raw)) {
+        return 'lightstrip';
+    }
+    if (['color bulb', 'ceiling light', 'ceiling light pro', 'candle warmer lamp', 'floor lamp'].includes(raw)) {
+        return 'light';
+    }
+    // Sensor variants
+    if (raw === 'motion sensor') {
+        return 'motion';
+    }
+    if (['contact sensor', 'presence sensor'].includes(raw)) {
+        return 'contact';
+    }
+    // Lock variants
+    if (['smart lock', 'smart lock pro', 'smart lock ultra', 'lock lite', 'keypad', 'keypad touch', 'keypad vision', 'keypad vision pro', 'lock vision pro'].includes(raw)) {
+        return 'lock';
+    }
+    // Climate variant
+    if (raw === 'humidifier2') {
+        return 'humidifier';
+    }
+    return raw;
+}
+// Factory function to create Matter handlers with Homebridge logger integration
+function createMatterHandlers(log, deviceId, type, client) {
+    const lowerType = type.toLowerCase();
+    switch (lowerType) {
+        case 'vacuum':
+            return {
+                rvcRunMode: {
+                    changeToMode: async (request) => {
+                        const modeNames = ['Idle', 'Cleaning', 'Mapping'];
+                        const modeName = modeNames[request?.newMode] || `Unknown (${request?.newMode})`;
+                        log.info(`[${deviceId}] RVC run mode change requested: ${modeName}`);
+                        if (!client) {
+                            log.warn(`[${deviceId}] No SwitchBot client available`);
+                            return { success: false };
+                        }
+                        try {
+                            // For K10+ family: use 'start' to begin cleaning (mode 1 = Cleaning)
+                            // For older K10+: only supports start/stop/dock
+                            // For newer K20+/S10/S20: supports startClean with more parameters
+                            // Map Matter mode to SwitchBot command
+                            const switchBotCommand = request?.newMode === 1 ? 'start' : 'stop';
+                            const body = {
+                                command: switchBotCommand,
+                                parameter: 'default',
+                                commandType: 'command',
+                            };
+                            log.debug(`[${deviceId}] Sending RVC mode change request:`, JSON.stringify(body));
+                            const result = await client.setDeviceState(deviceId, body);
+                            log.debug(`[${deviceId}] RVC mode change API response:`, JSON.stringify(result));
+                            log.info(`[${deviceId}] RVC mode changed successfully to ${switchBotCommand}`);
+                            return { success: true, result };
+                        }
+                        catch (e) {
+                            log.error(`[${deviceId}] Failed to change RVC mode:`, e);
+                            return { success: false, error: e };
+                        }
+                    },
+                },
+                rvcCleanMode: {
+                    changeToMode: async (request) => {
+                        const modeName = request?.newMode !== undefined ? `Mode ${request.newMode}` : 'Unknown';
+                        log.info(`[${deviceId}] RVC clean mode change requested: ${modeName}`);
+                        if (!client) {
+                            log.warn(`[${deviceId}] No SwitchBot client available`);
+                            return { success: false };
+                        }
+                        try {
+                            // Clean mode (vacuum/mop/etc) not directly supported via Matter for K10+
+                            // K20+ Pro and newer models support via startClean action parameter
+                            log.info(`[${deviceId}] Clean mode change requires startClean command (not yet implemented for Matter)`);
+                            return { success: true };
+                        }
+                        catch (e) {
+                            log.error(`[${deviceId}] Failed to change RVC clean mode:`, e);
+                            return { success: false, error: e };
+                        }
+                    },
+                },
+                rvcOperationalState: {
+                    pause: async () => {
+                        log.info(`[${deviceId}] RVC pause command received`);
+                        if (!client) {
+                            log.warn(`[${deviceId}] No SwitchBot client available`);
+                            return { success: false };
+                        }
+                        try {
+                            const body = {
+                                command: 'stop',
+                                parameter: 'default',
+                                commandType: 'command',
+                            };
+                            log.debug(`[${deviceId}] Sending RVC pause request:`, JSON.stringify(body));
+                            const result = await client.setDeviceState(deviceId, body);
+                            log.debug(`[${deviceId}] RVC pause API response:`, JSON.stringify(result));
+                            log.info(`[${deviceId}] RVC paused successfully`);
+                            return { success: true, result };
+                        }
+                        catch (e) {
+                            log.error(`[${deviceId}] Failed to pause RVC:`, e);
+                            return { success: false, error: e };
+                        }
+                    },
+                    resume: async () => {
+                        log.info(`[${deviceId}] RVC resume command received`);
+                        if (!client) {
+                            log.warn(`[${deviceId}] No SwitchBot client available`);
+                            return { success: false };
+                        }
+                        try {
+                            const body = {
+                                command: 'start',
+                                parameter: 'default',
+                                commandType: 'command',
+                            };
+                            log.debug(`[${deviceId}] Sending RVC resume request:`, JSON.stringify(body));
+                            const result = await client.setDeviceState(deviceId, body);
+                            log.debug(`[${deviceId}] RVC resume API response:`, JSON.stringify(result));
+                            log.info(`[${deviceId}] RVC resumed successfully`);
+                            return { success: true, result };
+                        }
+                        catch (e) {
+                            log.error(`[${deviceId}] Failed to resume RVC:`, e);
+                            return { success: false, error: e };
+                        }
+                    },
+                    goHome: async () => {
+                        log.info(`[${deviceId}] RVC goHome command received`);
+                        if (!client) {
+                            log.warn(`[${deviceId}] No SwitchBot client available`);
+                            return { success: false };
+                        }
+                        try {
+                            const body = {
+                                command: 'dock',
+                                parameter: 'default',
+                                commandType: 'command',
+                            };
+                            log.debug(`[${deviceId}] Sending RVC goHome request:`, JSON.stringify(body));
+                            const result = await client.setDeviceState(deviceId, body);
+                            log.debug(`[${deviceId}] RVC goHome API response:`, JSON.stringify(result));
+                            log.info(`[${deviceId}] RVC sent to dock successfully`);
+                            return { success: true, result };
+                        }
+                        catch (e) {
+                            log.error(`[${deviceId}] Failed to send goHome command:`, e);
+                            return { success: false, error: e };
+                        }
+                    },
+                },
+            };
+        case 'bot':
+            return {
+                onOff: {
+                    on: async () => {
+                        log.info(`[${deviceId}] Bot ON command received`);
+                        if (!client) {
+                            log.warn(`[${deviceId}] No SwitchBot client available`);
+                            return { success: false };
+                        }
+                        try {
+                            const result = await client.setDeviceState(deviceId, {
+                                command: 'turnOn',
+                                parameter: 'default',
+                                commandType: 'command',
+                            });
+                            log.info(`[${deviceId}] Bot turned on successfully`);
+                            return { success: true, result };
+                        }
+                        catch (e) {
+                            log.error(`[${deviceId}] Failed to turn on Bot:`, e);
+                            return { success: false, error: e };
+                        }
+                    },
+                    off: async () => {
+                        log.info(`[${deviceId}] Bot OFF command received`);
+                        if (!client) {
+                            log.warn(`[${deviceId}] No SwitchBot client available`);
+                            return { success: false };
+                        }
+                        try {
+                            const result = await client.setDeviceState(deviceId, {
+                                command: 'turnOff',
+                                parameter: 'default',
+                                commandType: 'command',
+                            });
+                            log.info(`[${deviceId}] Bot turned off successfully`);
+                            return { success: true, result };
+                        }
+                        catch (e) {
+                            log.error(`[${deviceId}] Failed to turn off Bot:`, e);
+                            return { success: false, error: e };
+                        }
+                    },
+                },
+            };
+        case 'curtain':
+        case 'blindtilt':
+            return {
+                windowCovering: {
+                    goToLiftPercentage: async (request) => {
+                        const percentage = request?.liftPercent100thsValue;
+                        log.info(`[${deviceId}] Curtain position change requested: ${percentage}`);
+                        if (!client) {
+                            log.warn(`[${deviceId}] No SwitchBot client available`);
+                            return { success: false };
+                        }
+                        try {
+                            // Convert Matter percentage (0-10000) to SwitchBot (0-100)
+                            const position = Math.max(0, Math.min(100, Math.round((percentage || 0) / 100)));
+                            const result = await client.setDeviceState(deviceId, {
+                                command: 'setPosition',
+                                parameter: String(position),
+                                commandType: 'command',
+                            });
+                            log.info(`[${deviceId}] Curtain position set to ${position}% successfully`);
+                            return { success: true, result };
+                        }
+                        catch (e) {
+                            log.error(`[${deviceId}] Failed to set curtain position:`, e);
+                            return { success: false, error: e };
+                        }
+                    },
+                    upOrOpen: async () => {
+                        log.info(`[${deviceId}] Curtain open command received`);
+                        if (!client) {
+                            log.warn(`[${deviceId}] No SwitchBot client available`);
+                            return { success: false };
+                        }
+                        try {
+                            const result = await client.setDeviceState(deviceId, {
+                                command: 'open',
+                                parameter: 'default',
+                                commandType: 'command',
+                            });
+                            log.info(`[${deviceId}] Curtain opened successfully`);
+                            return { success: true, result };
+                        }
+                        catch (e) {
+                            log.error(`[${deviceId}] Failed to open curtain:`, e);
+                            return { success: false, error: e };
+                        }
+                    },
+                    downOrClose: async () => {
+                        log.info(`[${deviceId}] Curtain close command received`);
+                        if (!client) {
+                            log.warn(`[${deviceId}] No SwitchBot client available`);
+                            return { success: false };
+                        }
+                        try {
+                            const result = await client.setDeviceState(deviceId, {
+                                command: 'close',
+                                parameter: 'default',
+                                commandType: 'command',
+                            });
+                            log.info(`[${deviceId}] Curtain closed successfully`);
+                            return { success: true, result };
+                        }
+                        catch (e) {
+                            log.error(`[${deviceId}] Failed to close curtain:`, e);
+                            return { success: false, error: e };
+                        }
+                    },
+                    stopMotion: async () => {
+                        log.info(`[${deviceId}] Curtain stop command received`);
+                        if (!client) {
+                            log.warn(`[${deviceId}] No SwitchBot client available`);
+                            return { success: false };
+                        }
+                        try {
+                            const result = await client.setDeviceState(deviceId, {
+                                command: 'pause',
+                                parameter: 'default',
+                                commandType: 'command',
+                            });
+                            log.info(`[${deviceId}] Curtain motion stopped successfully`);
+                            return { success: true, result };
+                        }
+                        catch (e) {
+                            log.error(`[${deviceId}] Failed to stop curtain:`, e);
+                            return { success: false, error: e };
+                        }
+                    },
+                },
+            };
+        case 'plug':
+            return {
+                onOff: {
+                    on: async () => {
+                        log.info(`[${deviceId}] Plug ON command received`);
+                        if (!client) {
+                            log.warn(`[${deviceId}] No SwitchBot client available`);
+                            return { success: false };
+                        }
+                        try {
+                            const result = await client.setDeviceState(deviceId, {
+                                command: 'turnOn',
+                                parameter: 'default',
+                                commandType: 'command',
+                            });
+                            log.info(`[${deviceId}] Plug turned on successfully`);
+                            return { success: true, result };
+                        }
+                        catch (e) {
+                            log.error(`[${deviceId}] Failed to turn on plug:`, e);
+                            return { success: false, error: e };
+                        }
+                    },
+                    off: async () => {
+                        log.info(`[${deviceId}] Plug OFF command received`);
+                        if (!client) {
+                            log.warn(`[${deviceId}] No SwitchBot client available`);
+                            return { success: false };
+                        }
+                        try {
+                            const result = await client.setDeviceState(deviceId, {
+                                command: 'turnOff',
+                                parameter: 'default',
+                                commandType: 'command',
+                            });
+                            log.info(`[${deviceId}] Plug turned off successfully`);
+                            return { success: true, result };
+                        }
+                        catch (e) {
+                            log.error(`[${deviceId}] Failed to turn off plug:`, e);
+                            return { success: false, error: e };
+                        }
+                    },
+                },
+            };
+        case 'lock':
+            return {
+                doorLock: {
+                    setLockState: async (request) => {
+                        const state = request?.lockState === 1 ? 'LOCKED' : 'UNLOCKED';
+                        log.info(`[${deviceId}] Lock state change requested: ${state}`);
+                        if (!client) {
+                            log.warn(`[${deviceId}] No SwitchBot client available`);
+                            return { success: false };
+                        }
+                        try {
+                            const command = request?.lockState === 1 ? 'lock' : 'unlock';
+                            const result = await client.setDeviceState(deviceId, {
+                                command,
+                                parameter: 'default',
+                                commandType: 'command',
+                            });
+                            log.info(`[${deviceId}] Lock ${state} successfully`);
+                            return { success: true, result };
+                        }
+                        catch (e) {
+                            log.error(`[${deviceId}] Failed to change lock state:`, e);
+                            return { success: false, error: e };
+                        }
+                    },
+                },
+            };
+        case 'fan':
+            return {
+                onOff: {
+                    on: async () => {
+                        log.info(`[${deviceId}] Fan ON command received`);
+                        if (!client) {
+                            log.warn(`[${deviceId}] No SwitchBot client available`);
+                            return { success: false };
+                        }
+                        try {
+                            const result = await client.setDeviceState(deviceId, {
+                                command: 'turnOn',
+                                parameter: 'default',
+                                commandType: 'command',
+                            });
+                            log.info(`[${deviceId}] Fan turned on successfully`);
+                            return { success: true, result };
+                        }
+                        catch (e) {
+                            log.error(`[${deviceId}] Failed to turn on fan:`, e);
+                            return { success: false, error: e };
+                        }
+                    },
+                    off: async () => {
+                        log.info(`[${deviceId}] Fan OFF command received`);
+                        if (!client) {
+                            log.warn(`[${deviceId}] No SwitchBot client available`);
+                            return { success: false };
+                        }
+                        try {
+                            const result = await client.setDeviceState(deviceId, {
+                                command: 'turnOff',
+                                parameter: 'default',
+                                commandType: 'command',
+                            });
+                            log.info(`[${deviceId}] Fan turned off successfully`);
+                            return { success: true, result };
+                        }
+                        catch (e) {
+                            log.error(`[${deviceId}] Failed to turn off fan:`, e);
+                            return { success: false, error: e };
+                        }
+                    },
+                },
+                fanControl: {
+                    setFanSpeed: async (request) => {
+                        const speed = request?.percentSetting || 0;
+                        log.info(`[${deviceId}] Fan speed change requested: ${speed}%`);
+                        if (!client) {
+                            log.warn(`[${deviceId}] No SwitchBot client available`);
+                            return { success: false };
+                        }
+                        try {
+                            // Convert percentage to SwitchBot fan speed parameter
+                            const speedParam = Math.max(1, Math.min(100, speed));
+                            const result = await client.setDeviceState(deviceId, {
+                                command: 'setFanSpeed',
+                                parameter: String(speedParam),
+                                commandType: 'command',
+                            });
+                            log.info(`[${deviceId}] Fan speed set to ${speedParam}% successfully`);
+                            return { success: true, result };
+                        }
+                        catch (e) {
+                            log.error(`[${deviceId}] Failed to set fan speed:`, e);
+                            return { success: false, error: e };
+                        }
+                    },
+                },
+            };
+        case 'light':
+            return {
+                onOff: {
+                    on: async () => {
+                        log.info(`[${deviceId}] Light ON command received`);
+                        if (!client) {
+                            log.warn(`[${deviceId}] No SwitchBot client available`);
+                            return { success: false };
+                        }
+                        try {
+                            const result = await client.setDeviceState(deviceId, {
+                                command: 'turnOn',
+                                parameter: 'default',
+                                commandType: 'command',
+                            });
+                            log.info(`[${deviceId}] Light turned on successfully`);
+                            return { success: true, result };
+                        }
+                        catch (e) {
+                            log.error(`[${deviceId}] Failed to turn on light:`, e);
+                            return { success: false, error: e };
+                        }
+                    },
+                    off: async () => {
+                        log.info(`[${deviceId}] Light OFF command received`);
+                        if (!client) {
+                            log.warn(`[${deviceId}] No SwitchBot client available`);
+                            return { success: false };
+                        }
+                        try {
+                            const result = await client.setDeviceState(deviceId, {
+                                command: 'turnOff',
+                                parameter: 'default',
+                                commandType: 'command',
+                            });
+                            log.info(`[${deviceId}] Light turned off successfully`);
+                            return { success: true, result };
+                        }
+                        catch (e) {
+                            log.error(`[${deviceId}] Failed to turn off light:`, e);
+                            return { success: false, error: e };
+                        }
+                    },
+                },
+                levelControl: {
+                    moveToLevel: async (request) => {
+                        const level = request?.level || 0;
+                        // Convert from 0-254 to 0-100
+                        const brightness = Math.round((level / 254) * 100);
+                        log.info(`[${deviceId}] Light brightness change requested: ${brightness}%`);
+                        if (!client) {
+                            log.warn(`[${deviceId}] No SwitchBot client available`);
+                            return { success: false };
+                        }
+                        try {
+                            const param = Math.max(0, Math.min(100, brightness));
+                            const result = await client.setDeviceState(deviceId, {
+                                command: 'setBrightness',
+                                parameter: String(param),
+                                commandType: 'command',
+                            });
+                            log.info(`[${deviceId}] Light brightness set to ${param}% successfully`);
+                            return { success: true, result };
+                        }
+                        catch (e) {
+                            log.error(`[${deviceId}] Failed to set light brightness:`, e);
+                            return { success: false, error: e };
+                        }
+                    },
+                },
+            };
+        case 'lightstrip':
+            return {
+                onOff: {
+                    on: async () => {
+                        log.info(`[${deviceId}] Lightstrip ON command received`);
+                        if (!client) {
+                            log.warn(`[${deviceId}] No SwitchBot client available`);
+                            return { success: false };
+                        }
+                        try {
+                            const result = await client.setDeviceState(deviceId, {
+                                command: 'turnOn',
+                                parameter: 'default',
+                                commandType: 'command',
+                            });
+                            log.info(`[${deviceId}] Lightstrip turned on successfully`);
+                            return { success: true, result };
+                        }
+                        catch (e) {
+                            log.error(`[${deviceId}] Failed to turn on lightstrip:`, e);
+                            return { success: false, error: e };
+                        }
+                    },
+                    off: async () => {
+                        log.info(`[${deviceId}] Lightstrip OFF command received`);
+                        if (!client) {
+                            log.warn(`[${deviceId}] No SwitchBot client available`);
+                            return { success: false };
+                        }
+                        try {
+                            const result = await client.setDeviceState(deviceId, {
+                                command: 'turnOff',
+                                parameter: 'default',
+                                commandType: 'command',
+                            });
+                            log.info(`[${deviceId}] Lightstrip turned off successfully`);
+                            return { success: true, result };
+                        }
+                        catch (e) {
+                            log.error(`[${deviceId}] Failed to turn off lightstrip:`, e);
+                            return { success: false, error: e };
+                        }
+                    },
+                },
+                levelControl: {
+                    moveToLevel: async (request) => {
+                        const level = request?.level || 0;
+                        // Convert from 0-254 to 0-100
+                        const brightness = Math.round((level / 254) * 100);
+                        log.info(`[${deviceId}] Lightstrip brightness change requested: ${brightness}%`);
+                        if (!client) {
+                            log.warn(`[${deviceId}] No SwitchBot client available`);
+                            return { success: false };
+                        }
+                        try {
+                            const param = Math.max(0, Math.min(100, brightness));
+                            const result = await client.setDeviceState(deviceId, {
+                                command: 'setBrightness',
+                                parameter: String(param),
+                                commandType: 'command',
+                            });
+                            log.info(`[${deviceId}] Lightstrip brightness set to ${param}% successfully`);
+                            return { success: true, result };
+                        }
+                        catch (e) {
+                            log.error(`[${deviceId}] Failed to set lightstrip brightness:`, e);
+                            return { success: false, error: e };
+                        }
+                    },
+                },
+                colorControl: {
+                    moveToHueAndSaturation: async (request) => {
+                        const hue = request?.hue || 0;
+                        const saturation = request?.saturation || 0;
+                        log.info(`[${deviceId}] Lightstrip color change requested: hue=${hue}, sat=${saturation}`);
+                        if (!client) {
+                            log.warn(`[${deviceId}] No SwitchBot client available`);
+                            return { success: false };
+                        }
+                        try {
+                            // Convert hue (0-254) and saturation (0-254) to combined color parameter
+                            // SwitchBot typically expects RGB or HSV format as parameter
+                            const colorParam = `${Math.round(hue)},${Math.round(saturation)}`;
+                            const result = await client.setDeviceState(deviceId, {
+                                command: 'setColor',
+                                parameter: colorParam,
+                                commandType: 'command',
+                            });
+                            log.info(`[${deviceId}] Lightstrip color set successfully`);
+                            return { success: true, result };
+                        }
+                        catch (e) {
+                            log.error(`[${deviceId}] Failed to set lightstrip color:`, e);
+                            return { success: false, error: e };
+                        }
+                    },
+                    moveToColorTemperature: async (request) => {
+                        const mireds = request?.colorTemperatureMireds || 400;
+                        // Convert mireds (158-500 typical range) to Kelvin: K = 1000000 / mireds
+                        const kelvin = Math.round(1000000 / mireds);
+                        log.info(`[${deviceId}] Lightstrip color temperature change requested: ${mireds} mireds (${kelvin}K)`);
+                        if (!client) {
+                            log.warn(`[${deviceId}] No SwitchBot client available`);
+                            return { success: false };
+                        }
+                        try {
+                            // Map Kelvin to SwitchBot color temperature parameter (typically 0-100 or specific values)
+                            // Normalize to 0-100 scale where 0=warm (2700K) and 100=cool (6500K)
+                            const colorTempParam = Math.max(0, Math.min(100, Math.round(((kelvin - 2700) / 3800) * 100)));
+                            const result = await client.setDeviceState(deviceId, {
+                                command: 'setColorTemperature',
+                                parameter: String(colorTempParam),
+                                commandType: 'command',
+                            });
+                            log.info(`[${deviceId}] Lightstrip color temperature set to ${kelvin}K successfully`);
+                            return { success: true, result };
+                        }
+                        catch (e) {
+                            log.error(`[${deviceId}] Failed to set lightstrip color temperature:`, e);
+                            return { success: false, error: e };
+                        }
+                    },
+                },
+            };
+        case 'humidifier':
+            return {
+                onOff: {
+                    on: async () => {
+                        log.info(`[${deviceId}] Humidifier ON command received`);
+                        if (!client) {
+                            log.warn(`[${deviceId}] No SwitchBot client available`);
+                            return { success: false };
+                        }
+                        try {
+                            const result = await client.setDeviceState(deviceId, {
+                                command: 'turnOn',
+                                parameter: 'default',
+                                commandType: 'command',
+                            });
+                            log.info(`[${deviceId}] Humidifier turned on successfully`);
+                            return { success: true, result };
+                        }
+                        catch (e) {
+                            log.error(`[${deviceId}] Failed to turn on humidifier:`, e);
+                            return { success: false, error: e };
+                        }
+                    },
+                    off: async () => {
+                        log.info(`[${deviceId}] Humidifier OFF command received`);
+                        if (!client) {
+                            log.warn(`[${deviceId}] No SwitchBot client available`);
+                            return { success: false };
+                        }
+                        try {
+                            const result = await client.setDeviceState(deviceId, {
+                                command: 'turnOff',
+                                parameter: 'default',
+                                commandType: 'command',
+                            });
+                            log.info(`[${deviceId}] Humidifier turned off successfully`);
+                            return { success: true, result };
+                        }
+                        catch (e) {
+                            log.error(`[${deviceId}] Failed to turn off humidifier:`, e);
+                            return { success: false, error: e };
+                        }
+                    },
+                },
+                fanControl: {
+                    setFanSpeed: async (request) => {
+                        const speed = request?.percentSetting || 0;
+                        log.info(`[${deviceId}] Humidifier speed change requested: ${speed}%`);
+                        if (!client) {
+                            log.warn(`[${deviceId}] No SwitchBot client available`);
+                            return { success: false };
+                        }
+                        try {
+                            // Convert percentage to SwitchBot humidifier speed parameter
+                            const speedParam = Math.max(1, Math.min(100, speed));
+                            const result = await client.setDeviceState(deviceId, {
+                                command: 'setFanSpeed',
+                                parameter: String(speedParam),
+                                commandType: 'command',
+                            });
+                            log.info(`[${deviceId}] Humidifier speed set to ${speedParam}% successfully`);
+                            return { success: true, result };
+                        }
+                        catch (e) {
+                            log.error(`[${deviceId}] Failed to set humidifier speed:`, e);
+                            return { success: false, error: e };
+                        }
+                    },
+                },
+            };
+        case 'relay':
+            return {
+                onOff: {
+                    on: async () => {
+                        log.info(`[${deviceId}] Relay ON command received`);
+                        if (!client) {
+                            log.warn(`[${deviceId}] No SwitchBot client available`);
+                            return { success: false };
+                        }
+                        try {
+                            const result = await client.setDeviceState(deviceId, {
+                                command: 'turnOn',
+                                parameter: 'default',
+                                commandType: 'command',
+                            });
+                            log.info(`[${deviceId}] Relay turned on successfully`);
+                            return { success: true, result };
+                        }
+                        catch (e) {
+                            log.error(`[${deviceId}] Failed to turn on relay:`, e);
+                            return { success: false, error: e };
+                        }
+                    },
+                    off: async () => {
+                        log.info(`[${deviceId}] Relay OFF command received`);
+                        if (!client) {
+                            log.warn(`[${deviceId}] No SwitchBot client available`);
+                            return { success: false };
+                        }
+                        try {
+                            const result = await client.setDeviceState(deviceId, {
+                                command: 'turnOff',
+                                parameter: 'default',
+                                commandType: 'command',
+                            });
+                            log.info(`[${deviceId}] Relay turned off successfully`);
+                            return { success: true, result };
+                        }
+                        catch (e) {
+                            log.error(`[${deviceId}] Failed to turn off relay:`, e);
+                            return { success: false, error: e };
+                        }
+                    },
+                },
+            };
+        default:
+            return undefined;
+    }
+}
+function resolveMatterDeviceType(matterApi, type, createdDeviceType, clusters) {
+    if (createdDeviceType && typeof createdDeviceType === 'object' && typeof createdDeviceType.with === 'function') {
+        return createdDeviceType;
+    }
+    const lowerType = (typeof createdDeviceType === 'string' && createdDeviceType) ? createdDeviceType.toLowerCase() : (type || '').toLowerCase();
+    // Cluster-based upgrade for color lights if descriptor omitted device type.
+    const hasColorControl = !!clusters?.colorControl;
+    const inferredType = hasColorControl && lowerType === 'light'
+        ? 'lightstrip'
+        : lowerType;
+    const mappedKey = DEVICE_MATTER_DEVICE_TYPE_KEYS[inferredType] || 'OnOffSwitch';
+    return matterApi?.deviceTypes?.[mappedKey] || matterApi?.deviceTypes?.OnOffSwitch;
+}
+export class SwitchBotHAPPlatform {
+    api;
+    log;
+    config;
+    devices = [];
+    // cached accessories restored by Homebridge
+    accessories;
+    // Track last loaded config to detect changes
+    lastConfigHash = '';
+    configReloadInterval = null;
+    constructor(log, config, api) {
+        this.log = log;
+        this.config = config ?? {};
+        this.api = api;
+        this.accessories = new Map();
+        this.log.info('SwitchBot HAP platform initialized');
+        // Create/shared SwitchBot client and attach to config so child devices reuse it.
+        try {
+            const client = new SwitchBotClient(this.config);
+            void client.init();
+            this.config._client = client;
+        }
+        catch (e) {
+            this.log.debug('Failed to create shared SwitchBot client', e);
+        }
+        // Create/shared SwitchBot client and attach to config so child devices reuse it.
+        try {
+            const client = new SwitchBotClient(this.config);
+            void client.init();
+            this.config._client = client;
+        }
+        catch (e) {
+            this.log.debug('Failed to create shared SwitchBot client', e);
+        }
+        // Wait for Homebridge to finish launching to create/register accessories
+        if (this.api && typeof this.api.on === 'function') {
+            this.api.on('didFinishLaunching', async () => {
+                await this.loadDevicesWithMatterInit();
+                // Start periodic config reload to pick up UI changes
+                this.configReloadInterval = setInterval(() => {
+                    void this.loadDevicesWithMatterInit();
+                }, 10000); // Check every 10 seconds
+            });
+        }
+        else {
+            void this.loadDevicesWithMatterInit();
+            // Start periodic config reload to pick up UI changes
+            this.configReloadInterval = setInterval(() => {
+                void this.loadDevicesWithMatterInit();
+            }, 10000); // Check every 10 seconds
+        }
+    }
+    /**
+     * Ensures Matter API is loaded before loading devices.
+     */
+    async loadDevicesWithMatterInit() {
+        // Wait for Matter API to be loaded and available before loading devices
+        const maxAttempts = 20; // Wait up to 10 seconds (20 x 500ms)
+        let attempt = 0;
+        let matterLoaded = false;
+        if (this.api
+            && typeof this.api.isMatterAvailable === 'function'
+            && typeof this.api.isMatterEnabled === 'function'
+            && typeof this.api.loadMatterAPI === 'function') {
+            if (this.api.isMatterAvailable() && this.api.isMatterEnabled()) {
+                try {
+                    await this.api.loadMatterAPI();
+                    this.log.info('Homebridge Matter API loaded successfully');
+                }
+                catch (e) {
+                    this.log.warn('Failed to load Homebridge Matter API', e);
+                }
+                // Wait for api.matter to be available
+                while (attempt < maxAttempts) {
+                    if (this.api.matter) {
+                        matterLoaded = true;
+                        break;
+                    }
+                    await new Promise(res => setTimeout(res, 500));
+                    attempt++;
+                }
+                if (!matterLoaded) {
+                    this.log.warn('Matter API did not become available after loadMatterAPI()');
+                }
+            }
+        }
+        await this.loadDevices();
+    }
+    getConfigHash() {
+        // Create a simple hash of current device config to detect changes
+        const devices = this.config?.devices ?? [];
+        return JSON.stringify(devices.map((d) => ({
+            id: d.deviceId ?? d.id,
+            type: d.configDeviceType ?? d.type,
+            name: d.configDeviceName ?? d.name,
+        })));
+    }
+    async loadDevices() {
+        const devices = this.config?.devices ?? [];
+        for (const raw of devices) {
+            // Normalize config keys from UI schema to internal shape
+            const d = {
+                id: raw.deviceId ?? raw.id,
+                name: raw.configDeviceName ?? raw.name,
+                type: raw.configDeviceType ?? raw.type ?? raw.deviceType ?? 'unknown',
+                encryptionKey: raw.encryptionKey,
+                keyId: raw.keyId,
+                _raw: raw,
+            };
+            const type = normalizeTypeForMatter(d.type);
+            const matterSupported = !!DEVICE_MATTER_SUPPORTED[(type || '').toLowerCase()];
+            // Auto-detect Matter from Homebridge API, allow manual override via config
+            const matterAvailable = !!(this.api?.isMatterAvailable?.() && this.api?.isMatterEnabled?.());
+            const matterEnabled = matterAvailable || !!this.config.enableMatter;
+            const useMatter = !!(matterEnabled && matterSupported && (!!this.config.preferMatter || matterAvailable));
+            try {
+                const created = await createDevice({ id: d.id, type, name: d.name }, this.config, useMatter);
+                this.devices.push(created);
+                // Prefer Matter: try registering to the Matter child bridge first.
+                let matterRegistered = false;
+                if (useMatter) {
+                    // Only attempt Matter registration if api.matter is truly available
+                    const matterApi = this.api?.matter;
+                    if (this.api?.isMatterAvailable?.() && this.api?.isMatterEnabled?.() && matterApi && typeof matterApi.registerPlatformAccessories === 'function') {
+                        this.log.info(`Attempting Matter registration for ${d.id} (${type})`);
+                        try {
+                            const createdDesc = await created.createAccessory(this.api);
+                            const uuid = matterApi.uuid.generate(`${d.id}`);
+                            const defaultClusters = DEVICE_MATTER_CLUSTERS[type.toLowerCase()] || { onOff: { onOff: false } };
+                            const clusters = createdDesc.clusters || defaultClusters;
+                            const deviceType = resolveMatterDeviceType(matterApi, type, createdDesc.deviceType, clusters);
+                            const accessory = {
+                                UUID: uuid,
+                                displayName: createdDesc.name || d.name || type,
+                                deviceType,
+                                manufacturer: createdDesc.manufacturer || 'SwitchBot',
+                                model: createdDesc.model || type,
+                                serialNumber: createdDesc.serialNumber || d.id,
+                                reachable: createdDesc.reachable !== false,
+                                firmwareRevision: createdDesc.firmwareRevision || '1.0.0',
+                                hardwareRevision: createdDesc.hardwareRevision || '',
+                                clusters,
+                                handlers: createdDesc.handlers || createMatterHandlers(this.log, d.id, type, this.config?._client) || undefined,
+                                context: { deviceId: d.id, type, _created: true },
+                            };
+                            // Log the full accessory descriptor before registration
+                            this.log.info(`[MatterDebug] Accessory descriptor for ${d.id}:`, JSON.stringify({
+                                UUID: accessory.UUID,
+                                displayName: accessory.displayName,
+                                deviceType: typeof accessory.deviceType === 'object' && accessory.deviceType?.name ? accessory.deviceType.name : accessory.deviceType,
+                                clusters: accessory.clusters,
+                                context: accessory.context,
+                            }, null, 2));
+                            await matterApi.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [accessory]);
+                            this.accessories.set(uuid, accessory);
+                            matterRegistered = true;
+                            this.log.info(`[MatterDebug] Registered Matter accessory ${d.id} (${type}) with uuid=${uuid}`);
+                        }
+                        catch (e) {
+                            this.log.error(`[MatterDebug] Failed to register Matter accessory for ${d.id} (${type}):`, e && (e.stack || e.message || e));
+                        }
+                    }
+                    else {
+                        this.log.info(`Matter API not available for ${d.id} (${type}); skipping Matter registration and falling back to HAP`);
+                    }
+                }
+                // If Matter wasn't registered (either not supported, API missing, or registration failed), fall back to HAP registration.
+                if (!matterRegistered && this.api && this.api.hap) {
+                    // Basic HAP accessory creation using homebridge API when available
+                    try {
+                        const hap = this.api.hap;
+                        const uuid = hap.uuid.generate(`${d.id}`);
+                        // Reuse cached accessory if available by uuid
+                        let accessory = this.accessories.get(uuid);
+                        // If not found by uuid, attempt to find by stored deviceId in accessory.context
+                        if (!accessory) {
+                            for (const [, a] of this.accessories.entries()) {
+                                try {
+                                    if (a && a.context && a.context.deviceId === d.id) {
+                                        accessory = a;
+                                        break;
+                                    }
+                                }
+                                catch (e) {
+                                    // ignore
+                                }
+                            }
+                        }
+                        if (!accessory) {
+                            accessory = new this.api.platformAccessory(d.name || type, uuid);
+                            // Store device metadata on accessory.context for persistence across restarts
+                            try {
+                                accessory.context = accessory.context || {};
+                                accessory.context.deviceId = d.id;
+                                accessory.context.type = type;
+                            }
+                            catch (e) {
+                                // ignore context failures
+                            }
+                            // Register new accessory with Homebridge so it's cached
+                            try {
+                                ;
+                                this.api.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [accessory]);
+                            }
+                            catch (e) {
+                                // older API variations may require different registration; ignore if unavailable
+                            }
+                            this.accessories.set(uuid, accessory);
+                        }
+                        else {
+                            // ensure context includes deviceId (in case restored accessory lacked it)
+                            try {
+                                accessory.context = accessory.context || {};
+                                accessory.context.deviceId = accessory.context.deviceId || d.id;
+                                accessory.context.type = accessory.context.type || type;
+                            }
+                            catch (e) {
+                                // ignore
+                            }
+                        }
+                        // Add basic service descriptor from device
+                        const accDesc = await created.createAccessory?.(this.api);
+                        if (accDesc && accDesc.services) {
+                            for (const s of accDesc.services) {
+                                const Service = hap.Service[s.type] || hap.Service[s.type];
+                                if (!Service) {
+                                    continue;
+                                }
+                                const service = accessory.getService(Service) || accessory.addService(Service);
+                                for (const [charName, getterSetterRaw] of Object.entries(s.characteristics || {})) {
+                                    const getterSetter = getterSetterRaw;
+                                    const Characteristic = hap.Characteristic[charName];
+                                    if (!Characteristic) {
+                                        continue;
+                                    }
+                                    // Apply characteristic props if provided (min/max/step)
+                                    if (getterSetter && getterSetter.props) {
+                                        try {
+                                            service.getCharacteristic(Characteristic).setProps(getterSetter.props);
+                                        }
+                                        catch (e) {
+                                            // ignore setProps failures on older HAP implementations
+                                        }
+                                    }
+                                    // Wire simple get/set handlers if provided
+                                    if (getterSetter && typeof getterSetter.get === 'function') {
+                                        service.getCharacteristic(Characteristic).onGet(getterSetter.get);
+                                    }
+                                    if (getterSetter && typeof getterSetter.set === 'function') {
+                                        service.getCharacteristic(Characteristic).onSet(getterSetter.set);
+                                    }
+                                }
+                            }
+                        }
+                        this.log.info(`Created/updated HAP accessory ${d.id} (${type})`);
+                    }
+                    catch (e) {
+                        this.log.warn('HAP accessory creation failed', e);
+                    }
+                }
+                else if (!matterRegistered) {
+                    this.log.info(`Created HAP descriptor for ${d.id} (${type}) (API not available to register)`);
+                }
+            }
+            catch (e) {
+                this.log.error(`Failed to create device ${d.id}:`, e);
+            }
+        }
+        // Update hash after successfully loading devices
+        this.lastConfigHash = this.getConfigHash();
+    }
+    // Example lifecycle method called by Homebridge
+    async configureAccessory(accessory) {
+        // Homebridge calls this for restored cached accessories — keep a reference.
+        try {
+            const uuid = accessory.UUID || accessory.UUID;
+            this.accessories.set(uuid, accessory);
+            this.log.info(`Restored cached accessory ${accessory.displayName || uuid}`);
+        }
+        catch (e) {
+            this.log.warn('configureAccessory failed to restore accessory', e);
+        }
+    }
+    // Called by Homebridge when a cached Matter accessory is restored
+    configureMatterAccessory(accessory) {
+        try {
+            const uuid = accessory.uuid || accessory.UUID || accessory.uuid;
+            this.accessories.set(uuid, accessory);
+            this.log.info(`Restored cached Matter accessory ${accessory.displayName || uuid}`);
+        }
+        catch (e) {
+            this.log.warn('configureMatterAccessory failed to restore accessory', e);
+        }
+    }
+}
+// Matter platform implementation (placeholder)
+export class SwitchBotMatterPlatform {
+    api;
+    log;
+    config;
+    devices = [];
+    accessories;
+    // Track last loaded config to detect changes
+    lastConfigHash = '';
+    configReloadInterval = null;
+    constructor(log, config, api) {
+        this.log = log;
+        this.config = config ?? {};
+        this.api = api;
+        this.accessories = new Map();
+        this.log.info('SwitchBot Matter platform initialized');
+        if (this.api && typeof this.api.on === 'function') {
+            ;
+            this.api.on('didFinishLaunching', () => {
+                ;
+                (async () => {
+                    // After launch, perform discovery (if any) and register Matter accessories
+                    try {
+                        await this.loadDevices();
+                        if (this.api.isMatterAvailable?.() && this.api.isMatterEnabled?.() && this.api.matter && typeof this.api.matter.registerPlatformAccessories === 'function') {
+                            try {
+                                await this.registerMatterAccessories?.();
+                            }
+                            catch (e) {
+                                this.log.warn('registerMatterAccessories failed', e);
+                            }
+                        }
+                    }
+                    catch (e) {
+                        this.log.warn('Error during Matter platform startup', e);
+                    }
+                })();
+                // Start periodic config reload to pick up UI changes
+                this.configReloadInterval = setInterval(() => {
+                    void this.checkAndReloadDevices();
+                }, 10000); // Check every 10 seconds
+            });
+        }
+        else {
+            void this.loadDevices();
+            // Start periodic config reload to pick up UI changes
+            this.configReloadInterval = setInterval(() => {
+                void this.checkAndReloadDevices();
+            }, 10000); // Check every 10 seconds
+        }
+        // Create/shared SwitchBot client and attach to config so child devices reuse it.
+        try {
+            const client = new SwitchBotClient(this.config);
+            void client.init();
+            this.config._client = client;
+        }
+        catch (e) {
+            this.log.debug('Failed to create shared SwitchBot client', e);
+        }
+    }
+    async loadDevices() {
+        const devices = this.config?.devices ?? [];
+        for (const raw of devices) {
+            // Normalize config keys produced by the UI schema
+            const d = {
+                id: raw.deviceId ?? raw.id,
+                name: raw.configDeviceName ?? raw.name,
+                type: raw.configDeviceType ?? raw.type ?? raw.deviceType ?? 'unknown',
+                _raw: raw,
+            };
+            const type = normalizeTypeForMatter(d.type);
+            const matterSupported = !!DEVICE_MATTER_SUPPORTED[(type || '').toLowerCase()];
+            // Auto-detect Matter from Homebridge API, allow manual override via config
+            const matterAvailable = this.api?.isMatterAvailable?.() && this.api?.isMatterEnabled?.();
+            const matterEnabled = matterAvailable || !!this.config.enableMatter;
+            const useMatter = matterEnabled && matterSupported;
+            try {
+                const created = await createDevice({ id: d.id, type, name: d.name }, this.config, useMatter);
+                this.devices.push(created);
+                if (useMatter) {
+                    this.log.info(`Prepared Matter accessory for ${d.id} (${type})${matterAvailable ? ' (auto-detected)' : ' (manually enabled)'}`);
+                }
+                else {
+                    if (!matterEnabled) {
+                        this.log.info(`Skipping Matter for ${d.id} (${type}) - Matter not available on this bridge`);
+                    }
+                    else if (!matterSupported) {
+                        this.log.info(`Skipping Matter for ${d.id} (${type}) - device type not supported`);
+                    }
+                    else {
+                        this.log.info(`Skipping Matter for ${d.id} (${type}) - not supported`);
+                    }
+                }
+            }
+            catch (e) {
+                this.log.error(`Failed to create Matter device ${d.id}:`, e);
+            }
+        }
+        // Update hash after successfully loading devices
+        this.lastConfigHash = this.getConfigHash();
+    }
+    getConfigHash() {
+        // Create a simple hash of current device config to detect changes
+        const devices = this.config?.devices ?? [];
+        return JSON.stringify(devices.map((d) => ({
+            id: d.deviceId ?? d.id,
+            type: d.configDeviceType ?? d.type,
+            name: d.configDeviceName ?? d.name,
+        })));
+    }
+    async checkAndReloadDevices() {
+        const currentHash = this.getConfigHash();
+        if (currentHash !== this.lastConfigHash) {
+            this.log.info('[SwitchBot] Detected config changes, reloading devices...');
+            // Clear existing devices
+            this.devices = [];
+            await this.loadDevices();
+        }
+    }
+    async configureAccessory(accessory) {
+        try {
+            const uuid = accessory.UUID || accessory.UUID;
+            this.accessories.set(uuid, accessory);
+            this.log.info(`Restored cached Matter accessory ${accessory.displayName || uuid}`);
+        }
+        catch (e) {
+            this.log.warn('configureAccessory failed to restore Matter accessory', e);
+        }
+    }
+    // Homebridge calls this when restoring cached Matter accessories
+    configureMatterAccessory(accessory) {
+        try {
+            const uuid = accessory.uuid || accessory.UUID || accessory.uuid;
+            this.accessories.set(uuid, accessory);
+            this.log.info(`Restored cached Matter accessory ${accessory.displayName || uuid}`);
+        }
+        catch (e) {
+            this.log.warn('configureMatterAccessory failed to restore Matter accessory', e);
+        }
+    }
+    // Register serialized Matter accessories via Homebridge Matter API
+    async registerMatterAccessories() {
+        if (!this.api) {
+            return;
+        }
+        const matterApi = this.api.matter;
+        if (!matterApi || typeof matterApi.registerPlatformAccessories !== 'function') {
+            this.log.info('Homebridge Matter API not available; skipping Matter accessory registration');
+            return;
+        }
+        const devices = this.config?.devices ?? [];
+        const accessoriesToRegister = [];
+        // Auto-detect Matter from Homebridge API
+        const matterAvailable = this.api?.isMatterAvailable?.() && this.api?.isMatterEnabled?.();
+        const matterEnabled = matterAvailable || !!this.config.enableMatter;
+        for (const raw of devices) {
+            const d = {
+                id: raw.deviceId ?? raw.id,
+                name: raw.configDeviceName ?? raw.name,
+                type: raw.configDeviceType ?? raw.type ?? raw.deviceType ?? 'unknown',
+            };
+            if (!d.id) {
+                continue;
+            }
+            const type = normalizeTypeForMatter(d.type);
+            const matterSupported = !!DEVICE_MATTER_SUPPORTED[(type || '').toLowerCase()];
+            const useMatter = matterEnabled && matterSupported;
+            if (!useMatter) {
+                continue;
+            }
+            try {
+                const created = await createDevice({ id: d.id, type, name: d.name }, this.config, true);
+                const createdDesc = await created.createAccessory(this.api);
+                const uuid = matterApi.uuid.generate(`${d.id}`);
+                // Try to find existing restored accessory by deviceId
+                let existing;
+                for (const [, a] of this.accessories.entries()) {
+                    try {
+                        if (a && a.context && a.context.deviceId === d.id) {
+                            existing = a;
+                            break;
+                        }
+                    }
+                    catch (e) {
+                        // ignore
+                    }
+                }
+                if (existing) {
+                    // Ensure context and displayName are up to date
+                    // Prioritize device-specific Matter clusters (e.g., RVC for vacuum) over generic HAP-derived clusters
+                    let clusters = DEVICE_MATTER_CLUSTERS[type.toLowerCase()];
+                    if (!clusters) {
+                        clusters = existing.clusters || createdDesc.clusters || { onOff: { onOff: false } };
+                    }
+                    const deviceType = resolveMatterDeviceType(matterApi, type, existing.deviceType || createdDesc.deviceType, clusters);
+                    existing.context = existing.context || {};
+                    existing.context.deviceId = existing.context.deviceId || d.id;
+                    existing.context.type = existing.context.type || type;
+                    existing.deviceType = deviceType;
+                    existing.manufacturer = existing.manufacturer || createdDesc.manufacturer || 'SwitchBot';
+                    existing.model = existing.model || createdDesc.model || type;
+                    existing.serialNumber = existing.serialNumber || createdDesc.serialNumber || d.id;
+                    existing.reachable = existing.reachable !== false;
+                    existing.firmwareRevision = existing.firmwareRevision || createdDesc.firmwareRevision || '1.0.0';
+                    existing.hardwareRevision = existing.hardwareRevision || createdDesc.hardwareRevision || '';
+                    existing.clusters = clusters;
+                    existing.handlers = createdDesc.handlers || createMatterHandlers(this.log, d.id, type, this.config?._client) || undefined;
+                    existing.displayName = createdDesc.name || d.name || type;
+                    existing.UUID = existing.UUID || existing.uuid || uuid;
+                    accessoriesToRegister.push(existing);
+                    this.accessories.set(existing.UUID || uuid, existing);
+                }
+                else {
+                    // Prioritize device-specific Matter clusters (e.g., RVC for vacuum) over generic HAP-derived clusters
+                    let clusters = DEVICE_MATTER_CLUSTERS[type.toLowerCase()];
+                    if (!clusters) {
+                        clusters = createdDesc.clusters || { onOff: { onOff: false } };
+                    }
+                    const deviceType = resolveMatterDeviceType(matterApi, type, createdDesc.deviceType, clusters);
+                    const serialized = {
+                        UUID: uuid,
+                        displayName: createdDesc.name || d.name || type,
+                        deviceType,
+                        manufacturer: createdDesc.manufacturer || 'SwitchBot',
+                        model: createdDesc.model || type,
+                        serialNumber: createdDesc.serialNumber || d.id,
+                        reachable: createdDesc.reachable !== false,
+                        firmwareRevision: createdDesc.firmwareRevision || '1.0.0',
+                        hardwareRevision: createdDesc.hardwareRevision || '',
+                        clusters,
+                        handlers: createdDesc.handlers || createMatterHandlers(this.log, d.id, type, this.config?._client) || undefined,
+                        context: { deviceId: d.id, type, created: true },
+                    };
+                    accessoriesToRegister.push(serialized);
+                    this.accessories.set(uuid, serialized);
+                }
+            }
+            catch (e) {
+                this.log.warn(`Failed to prepare Matter accessory for ${d.id} (${type})`, e);
+            }
+        }
+        if (accessoriesToRegister.length > 0) {
+            try {
+                await matterApi.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, accessoriesToRegister);
+                this.log.info(`Registered ${accessoriesToRegister.length} Matter accessory(ies) with Homebridge`);
+            }
+            catch (e) {
+                this.log.warn('Failed to register Matter accessories', e);
+            }
+        }
+        else {
+            this.log.info('No Matter accessories to register');
+        }
+    }
+}
+export default SwitchBotHAPPlatform;
+//# sourceMappingURL=platform.js.map