matterbridge-lg-thinq-plugin 0.1.0

package/dist/platform/thinq/thinqAirConditionerCommandHandlers.js

@@ -0,0 +1,190 @@
+import { FanControl, Thermostat } from 'matterbridge/matter/clusters';
+import { isValidNumber } from 'matterbridge/utils';
+export const THINQ_FAN_SPEED_AUTO = 8;
+export const THINQ_FAN_SPEED_LOW = 2;
+export const THINQ_FAN_SPEED_MEDIUM = 4;
+export const THINQ_FAN_SPEED_HIGH = 6;
+const THINQ_OPERATION_ON = 1;
+const THINQ_OPERATION_OFF = 0;
+const THINQ_TEMPERATURE_STEP_CELSIUS = 0.5;
+function withErrorHandling(commandName, logger, handler) {
+    return async () => {
+        try {
+            await handler();
+        }
+        catch (error) {
+            logger.error(`ThinQ AirConditioner command '${commandName}' failed: ${error instanceof Error ? error.message : String(error)}`);
+            throw error;
+        }
+    };
+}
+function roundToStep(value, step) {
+    return Math.round(value / step) * step;
+}
+function revertSetpointOnFailure(airConditioner, attribute, oldValue) {
+    return () => {
+        airConditioner.updateAttribute(Thermostat.id, attribute, oldValue, airConditioner.log).catch(() => {
+        });
+    };
+}
+function mapPercentToWindStrength(percent) {
+    if (percent === 0) {
+        return undefined;
+    }
+    if (percent <= 33) {
+        return THINQ_FAN_SPEED_LOW;
+    }
+    if (percent <= 66) {
+        return THINQ_FAN_SPEED_MEDIUM;
+    }
+    return THINQ_FAN_SPEED_HIGH;
+}
+function mapFanModeToWindStrength(fanMode) {
+    switch (fanMode) {
+        case FanControl.FanMode.Auto:
+            return THINQ_FAN_SPEED_AUTO;
+        case FanControl.FanMode.Low:
+            return THINQ_FAN_SPEED_LOW;
+        case FanControl.FanMode.Medium:
+            return THINQ_FAN_SPEED_MEDIUM;
+        case FanControl.FanMode.High:
+            return THINQ_FAN_SPEED_HIGH;
+        default:
+            return undefined;
+    }
+}
+export function registerAirConditionerCommandHandlers(airConditioner, device, apiClient, logger, capabilities) {
+    airConditioner.addCommandHandler('on', withErrorHandling('on', logger, async () => {
+        logger.debug(`ThinQ AirConditioner ${device.id}: 'on' command handler invoked, capabilities=${JSON.stringify(capabilities)}`);
+        await apiClient.sendCommand(device.id, {
+            command: 'Operation',
+            dataKey: 'airState.operation',
+            dataValue: THINQ_OPERATION_ON,
+        });
+    }));
+    airConditioner.addCommandHandler('off', withErrorHandling('off', logger, async () => {
+        logger.debug(`ThinQ AirConditioner ${device.id}: 'off' command handler invoked, capabilities=${JSON.stringify(capabilities)}`);
+        await apiClient.sendCommand(device.id, {
+            command: 'Operation',
+            dataKey: 'airState.operation',
+            dataValue: THINQ_OPERATION_OFF,
+        });
+    }));
+    airConditioner.subscribeAttribute(Thermostat.id, 'occupiedCoolingSetpoint', (newValue, oldValue, context) => {
+        if (context.fabric === undefined) {
+            return;
+        }
+        logger.debug(`ThinQ AirConditioner ${device.id}: 'occupiedCoolingSetpoint' command handler invoked, newValue=${newValue}, capabilities=${JSON.stringify(capabilities)}`);
+        void withErrorHandling('occupiedCoolingSetpoint', logger, async () => {
+            await apiClient.sendCommand(device.id, {
+                dataKey: 'airState.tempState.target',
+                dataValue: roundToStep(newValue / 100, THINQ_TEMPERATURE_STEP_CELSIUS),
+            });
+        })().catch(revertSetpointOnFailure(airConditioner, 'occupiedCoolingSetpoint', oldValue));
+    }, airConditioner.log);
+    if (capabilities.supportsHeat) {
+        airConditioner.subscribeAttribute(Thermostat.id, 'occupiedHeatingSetpoint', (newValue, oldValue, context) => {
+            if (context.fabric === undefined) {
+                return;
+            }
+            logger.debug(`ThinQ AirConditioner ${device.id}: 'occupiedHeatingSetpoint' command handler invoked, newValue=${newValue}, capabilities=${JSON.stringify(capabilities)}`);
+            void withErrorHandling('occupiedHeatingSetpoint', logger, async () => {
+                await apiClient.sendCommand(device.id, {
+                    dataKey: 'airState.tempState.target',
+                    dataValue: roundToStep(newValue / 100, THINQ_TEMPERATURE_STEP_CELSIUS),
+                });
+            })().catch(revertSetpointOnFailure(airConditioner, 'occupiedHeatingSetpoint', oldValue));
+        }, airConditioner.log);
+    }
+    airConditioner.subscribeAttribute(FanControl, 'percentSetting', (newValue, _oldValue, context) => {
+        if (context.fabric === undefined) {
+            return;
+        }
+        logger.debug(`ThinQ AirConditioner ${device.id}: 'percentSetting' command handler invoked, newValue=${newValue}, capabilities=${JSON.stringify(capabilities)}`);
+        if (!capabilities.supportsFanSpeedControl) {
+            logger.debug(`ThinQ AirConditioner ${device.id}: ignoring percentSetting change — fan speed control not supported per configured capabilities.`);
+            return;
+        }
+        if (newValue === null || !isValidNumber(newValue, 0, 100)) {
+            return;
+        }
+        const windStrength = mapPercentToWindStrength(newValue);
+        if (windStrength === undefined) {
+            logger.debug(`ThinQ AirConditioner ${device.id}: ignoring percentSetting=0 (ambiguous, no ThinQ equivalent).`);
+            return;
+        }
+        void withErrorHandling('percentSetting', logger, async () => {
+            await apiClient.sendCommand(device.id, {
+                dataKey: 'airState.windStrength',
+                dataValue: windStrength,
+            });
+        })();
+    }, airConditioner.log);
+    airConditioner.subscribeAttribute(FanControl, 'fanMode', (newValue, _oldValue, context) => {
+        if (context.fabric === undefined) {
+            return;
+        }
+        logger.debug(`ThinQ AirConditioner ${device.id}: 'fanMode' command handler invoked, newValue=${FanControl.FanMode[newValue]}, capabilities=${JSON.stringify(capabilities)}`);
+        if (!capabilities.supportsFanSpeedControl) {
+            logger.debug(`ThinQ AirConditioner ${device.id}: ignoring fanMode change — fan speed control not supported per configured capabilities.`);
+            return;
+        }
+        const windStrength = mapFanModeToWindStrength(newValue);
+        if (windStrength === undefined) {
+            logger.debug(`ThinQ AirConditioner ${device.id}: ignoring fanMode=${FanControl.FanMode[newValue]} (no ThinQ equivalent).`);
+            return;
+        }
+        void withErrorHandling('fanMode', logger, async () => {
+            await apiClient.sendCommand(device.id, {
+                dataKey: 'airState.windStrength',
+                dataValue: windStrength,
+            });
+        })();
+    }, airConditioner.log);
+    if (capabilities.supportsSwingMode) {
+        airConditioner.subscribeAttribute(FanControl, 'rockSetting', (newValue, oldValue, context) => {
+            if (context.fabric === undefined) {
+                return;
+            }
+            const newRock = newValue;
+            const oldRock = oldValue;
+            logger.debug(`ThinQ AirConditioner ${device.id}: 'rockSetting' command handler invoked, newValue=${JSON.stringify(newRock)}, capabilities=${JSON.stringify(capabilities)}`);
+            if (!newRock || !oldRock) {
+                return;
+            }
+            const verticalChanged = newRock.rockUpDown !== oldRock.rockUpDown;
+            const horizontalChanged = newRock.rockLeftRight !== oldRock.rockLeftRight;
+            if (!verticalChanged && !horizontalChanged) {
+                return;
+            }
+            void withErrorHandling('rockSetting', logger, async () => {
+                if (verticalChanged && horizontalChanged && newRock.rockUpDown && newRock.rockLeftRight) {
+                    await apiClient.sendCommand(device.id, {
+                        dataKey: null,
+                        dataValue: null,
+                        command: 'Set',
+                        ctrlKey: 'favoriteCtrl',
+                        dataSetList: {
+                            'airState.wDir.vStep': '100',
+                            'airState.wDir.hStep': '100',
+                        },
+                    });
+                }
+                else {
+                    if (verticalChanged) {
+                        await apiClient.sendCommand(device.id, {
+                            dataKey: 'airState.wDir.vStep',
+                            dataValue: newRock.rockUpDown ? '100' : '0',
+                        });
+                    }
+                    if (horizontalChanged) {
+                        await apiClient.sendCommand(device.id, {
+                            dataKey: 'airState.wDir.hStep',
+                            dataValue: newRock.rockLeftRight ? '100' : '0',
+                        });
+                    }
+                }
+            })();
+        }, airConditioner.log);
+    }
+}

package/dist/platform/thinq/thinqAirConditionerEndpointFactory.js

@@ -0,0 +1,53 @@
+import { airQualitySensor, electricalSensor, humiditySensor, MatterbridgeEndpoint, powerSource, roomAirConditioner, } from 'matterbridge';
+import { AirQuality, FanControl, PowerTopology } from 'matterbridge/matter/clusters';
+export function buildAirConditionerEndpoint(device, capabilities, setpoints, initialFanMode, options) {
+    const { currentTemperature, targetTemperature, minHeatSetpointLimitCelsius, maxHeatSetpointLimitCelsius, minCoolSetpointLimitCelsius, maxCoolSetpointLimitCelsius, } = setpoints;
+    const endpoint = new MatterbridgeEndpoint(capabilities.supportsEnergyMonitoring
+        ? [roomAirConditioner, powerSource, electricalSensor]
+        : [roomAirConditioner, powerSource], {
+        id: `${device.name.replaceAll(' ', '')}-${device.id.replaceAll(' ', '')}`,
+    })
+        .createDefaultIdentifyClusterServer()
+        .createDefaultBasicInformationClusterServer(device.name, device.id, options?.vendorId ?? 0xfff1, options?.vendorName ?? 'Matterbridge', options?.productId ?? 0x8000, options?.productName ?? 'Matterbridge Air Conditioner')
+        .createDefaultPowerSourceWiredClusterServer()
+        .createDeadFrontOnOffClusterServer(true);
+    if (capabilities.supportsHeat) {
+        endpoint.createDefaultThermostatClusterServer(currentTemperature, targetTemperature, targetTemperature, 1, minHeatSetpointLimitCelsius, maxHeatSetpointLimitCelsius, minCoolSetpointLimitCelsius, maxCoolSetpointLimitCelsius);
+    }
+    else {
+        endpoint.createDefaultCoolingThermostatClusterServer(currentTemperature, targetTemperature, minCoolSetpointLimitCelsius, maxCoolSetpointLimitCelsius);
+    }
+    endpoint.createDefaultThermostatUserInterfaceConfigurationClusterServer();
+    if (capabilities.supportsFanSpeedControl && capabilities.supportsSwingMode) {
+        endpoint.createCompleteFanControlClusterServer(initialFanMode, FanControl.FanModeSequence.OffLowMedHighAuto, 0, 0, undefined, undefined, undefined, { rockLeftRight: true, rockUpDown: true, rockRound: true }, { rockLeftRight: false, rockUpDown: false, rockRound: false });
+    }
+    else if (capabilities.supportsFanSpeedControl) {
+        endpoint.createDefaultFanControlClusterServer(initialFanMode, FanControl.FanModeSequence.OffLowMedHighAuto, 0, 0);
+    }
+    else {
+        endpoint.createOnOffFanControlClusterServer(initialFanMode);
+    }
+    if (capabilities.supportsHumiditySensor) {
+        endpoint
+            .addChildDeviceType('HumiditySensor', [humiditySensor])
+            .createDefaultIdentifyClusterServer()
+            .createDefaultRelativeHumidityMeasurementClusterServer(0);
+    }
+    if (capabilities.supportsAirQualitySensor) {
+        endpoint
+            .addChildDeviceType('AirQualitySensor', [airQualitySensor])
+            .createDefaultIdentifyClusterServer()
+            .createDefaultAirQualityClusterServer(AirQuality.AirQualityEnum.Unknown)
+            .createDefaultPm25ConcentrationMeasurementClusterServer()
+            .createDefaultPm10ConcentrationMeasurementClusterServer();
+    }
+    if (capabilities.supportsEnergyMonitoring) {
+        endpoint
+            .createDefaultPowerTopologyClusterServer(PowerTopology.Feature.NodeTopology)
+            .createDefaultElectricalPowerMeasurementClusterServer(null, null, 0, null);
+    }
+    if (capabilities.supportsFilterMonitoring) {
+        endpoint.createDefaultHepaFilterMonitoringClusterServer();
+    }
+    return endpoint;
+}

package/dist/platform/thinq/thinqAirConditionerFilterResetCommandHandler.js

@@ -0,0 +1,54 @@
+import { ThinqFilterState } from '../../core/domain/value-objects/ThinqFilterState.js';
+const KEY_USE_TIME = 'airState.filterMngState.useTime';
+const KEY_REMAIN_TIME = 'airState.filterMngState.remainTime';
+const KEY_MAX_TIME = 'airState.filterMngState.maxTime';
+const KEY_CHANGE_DATE = 'airState.filterMngState.changeDate';
+export function resolveFilterResetPayload(filterState, now = new Date()) {
+    return {
+        [KEY_USE_TIME]: 0,
+        [KEY_REMAIN_TIME]: filterState.ratedMaxTimeHours,
+        [KEY_MAX_TIME]: filterState.ratedMaxTimeHours,
+        [KEY_CHANGE_DATE]: formatChangeDate(now),
+    };
+}
+function formatChangeDate(date) {
+    const year = date.getUTCFullYear();
+    const month = String(date.getUTCMonth() + 1).padStart(2, '0');
+    const day = String(date.getUTCDate()).padStart(2, '0');
+    return Number(`${year}${month}${day}`);
+}
+export function registerFilterResetCommandHandler(airConditioner, device, apiClient, logger, capabilities, filterResetControl) {
+    if (!capabilities.supportsFilterMonitoring) {
+        return;
+    }
+    airConditioner.addCommandHandler('resetCondition', async () => {
+        if (!filterResetControl.allowFilterReset) {
+            logger.warn(`ThinQ AirConditioner filter reset is disabled by configuration (deviceId=${device.id})`);
+            throw new Error('ThinQ AirConditioner filter reset is disabled by configuration.');
+        }
+        let filterState;
+        try {
+            filterState = ThinqFilterState.fromRaw(await apiClient.getFilterState(device.id));
+        }
+        catch (error) {
+            logger.error(`ThinQ AirConditioner filter reset failed to read current filter state: ${error instanceof Error ? error.message : String(error)} (deviceId=${device.id})`);
+            throw error;
+        }
+        if (!filterState) {
+            logger.warn(`ThinQ AirConditioner filter reset: no current filter data available, refusing to reset (deviceId=${device.id})`);
+            throw new Error('ThinQ AirConditioner filter reset: no current filter data available for this device.');
+        }
+        try {
+            await apiClient.sendCommand(device.id, {
+                ctrlKey: 'filterMngStateCtrl',
+                command: 'Set',
+                dataSetList: resolveFilterResetPayload(filterState),
+            });
+            logger.info(`ThinQ AirConditioner filter reset succeeded (deviceId=${device.id})`);
+        }
+        catch (error) {
+            logger.error(`ThinQ AirConditioner filter reset command failed: ${error instanceof Error ? error.message : String(error)} (deviceId=${device.id})`);
+            throw error;
+        }
+    });
+}

package/dist/platform/thinq/thinqAirConditionerFilterStateSync.js

@@ -0,0 +1,19 @@
+import { HepaFilterMonitoring, ResourceMonitoring } from 'matterbridge/matter/clusters';
+const FILTER_WARNING_THRESHOLD_PERCENT = 10;
+export function resolveFilterChangeIndication(remainingPercent) {
+    if (remainingPercent <= 0) {
+        return ResourceMonitoring.ChangeIndication.Critical;
+    }
+    if (remainingPercent <= FILTER_WARNING_THRESHOLD_PERCENT) {
+        return ResourceMonitoring.ChangeIndication.Warning;
+    }
+    return ResourceMonitoring.ChangeIndication.Ok;
+}
+export async function applyThinqFilterStateToAirConditioner(airConditioner, filterState, logger) {
+    if (!filterState) {
+        logger.debug('ThinQ filter state: no data, skipping HepaFilterMonitoring update.');
+        return;
+    }
+    await airConditioner.updateAttribute(HepaFilterMonitoring.id, 'condition', filterState.remainingPercent, logger);
+    await airConditioner.updateAttribute(HepaFilterMonitoring.id, 'changeIndication', resolveFilterChangeIndication(filterState.remainingPercent), logger);
+}

package/dist/platform/thinq/thinqAirConditionerStateSync.js

@@ -0,0 +1,205 @@
+import { AirQuality, ElectricalPowerMeasurement, FanControl, OnOff, Pm10ConcentrationMeasurement, Pm25ConcentrationMeasurement, RelativeHumidityMeasurement, TemperatureMeasurement, Thermostat, } from 'matterbridge/matter/clusters';
+import { THINQ_FAN_SPEED_AUTO, THINQ_FAN_SPEED_LOW, THINQ_FAN_SPEED_MEDIUM, } from './thinqAirConditionerCommandHandlers.js';
+import { mapWindStrengthToFanMode, mapWindStrengthToFixedFanMode } from './thinqDeviceConfigurator.js';
+const THINQ_OP_MODE_COOL = 0;
+const THINQ_OP_MODE_DRY = 1;
+const THINQ_OP_MODE_FAN = 2;
+const THINQ_OP_MODE_HEAT = 4;
+const THINQ_OP_MODE_AIR_CLEAN = 5;
+const THINQ_OP_MODE_AUTO = 6;
+const WIND_STRENGTH_LOW_PERCENT = 20;
+const WIND_STRENGTH_MEDIUM_PERCENT = 50;
+const WIND_STRENGTH_HIGH_PERCENT = 90;
+const KEY_OPERATION = 'airState.operation';
+const KEY_OP_MODE = 'airState.opMode';
+const KEY_TEMP_CURRENT = 'airState.tempState.current';
+const KEY_TEMP_TARGET = 'airState.tempState.target';
+const KEY_WIND_STRENGTH = 'airState.windStrength';
+const KEY_SWING_VERTICAL = 'airState.wDir.vStep';
+const KEY_SWING_HORIZONTAL = 'airState.wDir.hStep';
+export function mapWindStrengthToPercent(windStrength) {
+    if (windStrength === undefined || windStrength === THINQ_FAN_SPEED_AUTO) {
+        return undefined;
+    }
+    if (windStrength <= THINQ_FAN_SPEED_LOW) {
+        return WIND_STRENGTH_LOW_PERCENT;
+    }
+    if (windStrength <= THINQ_FAN_SPEED_MEDIUM) {
+        return WIND_STRENGTH_MEDIUM_PERCENT;
+    }
+    return WIND_STRENGTH_HIGH_PERCENT;
+}
+export function mapOperationModeToSystemMode(operationMode, isPowerOn, capabilities) {
+    if (!isPowerOn) {
+        return Thermostat.SystemMode.Off;
+    }
+    switch (operationMode) {
+        case THINQ_OP_MODE_AUTO:
+            return capabilities.supportsHeat ? Thermostat.SystemMode.Auto : Thermostat.SystemMode.Cool;
+        case THINQ_OP_MODE_COOL:
+            return Thermostat.SystemMode.Cool;
+        case THINQ_OP_MODE_HEAT:
+            return capabilities.supportsHeat ? Thermostat.SystemMode.Heat : Thermostat.SystemMode.Cool;
+        case THINQ_OP_MODE_FAN:
+            return Thermostat.SystemMode.Cool;
+        case THINQ_OP_MODE_DRY:
+            return Thermostat.SystemMode.Cool;
+        case THINQ_OP_MODE_AIR_CLEAN:
+        default:
+            return capabilities.supportsHeat ? Thermostat.SystemMode.Auto : Thermostat.SystemMode.Cool;
+    }
+}
+function resolveSystemModeUpdate(airConditioner, snapshot, capabilities) {
+    if (!snapshot.has(KEY_OPERATION)) {
+        if (!snapshot.has(KEY_OP_MODE)) {
+            return undefined;
+        }
+        const currentPowerOn = airConditioner.getAttribute(OnOff.id, 'onOff') === true;
+        if (!currentPowerOn) {
+            return undefined;
+        }
+        return mapOperationModeToSystemMode(snapshot.operationMode, true, capabilities);
+    }
+    const isPowerOn = snapshot.isPowerOn;
+    if (isPowerOn && !snapshot.has(KEY_OP_MODE)) {
+        return undefined;
+    }
+    return mapOperationModeToSystemMode(snapshot.operationMode, isPowerOn, capabilities);
+}
+function isKnownOff(airConditioner, snapshot) {
+    if (snapshot.has(KEY_OPERATION)) {
+        return !snapshot.isPowerOn;
+    }
+    return airConditioner.getAttribute(OnOff.id, 'onOff') === false;
+}
+function resolveRockSetting(airConditioner, snapshot) {
+    const hasVertical = snapshot.has(KEY_SWING_VERTICAL);
+    const hasHorizontal = snapshot.has(KEY_SWING_HORIZONTAL);
+    if (!hasVertical && !hasHorizontal) {
+        return undefined;
+    }
+    let verticalOn = snapshot.isVerticalSwingOn;
+    let horizontalOn = snapshot.isHorizontalSwingOn;
+    if (!hasVertical) {
+        const currentRockSetting = airConditioner.getAttribute(FanControl.id, 'rockSetting');
+        verticalOn = currentRockSetting?.rockUpDown ?? false;
+    }
+    if (!hasHorizontal) {
+        const currentRockSetting = airConditioner.getAttribute(FanControl.id, 'rockSetting');
+        horizontalOn = currentRockSetting?.rockLeftRight ?? false;
+    }
+    return {
+        rockLeftRight: horizontalOn,
+        rockUpDown: verticalOn,
+        rockRound: verticalOn && horizontalOn,
+    };
+}
+export async function applyThinqSnapshotToAirConditioner(airConditioner, snapshot, capabilities, logger) {
+    const deviceId = airConditioner.serialNumber ?? airConditioner.uniqueId ?? 'unknown';
+    const hasPower = snapshot.has(KEY_OPERATION);
+    const systemModeUpdate = resolveSystemModeUpdate(airConditioner, snapshot, capabilities);
+    const rockSetting = capabilities.supportsFanSpeedControl && capabilities.supportsSwingMode
+        ? resolveRockSetting(airConditioner, snapshot)
+        : undefined;
+    const attributesToPush = [];
+    const attributesToSkip = [];
+    if (hasPower) {
+        attributesToPush.push('power');
+    }
+    else {
+        attributesToSkip.push('power');
+    }
+    if (systemModeUpdate !== undefined) {
+        attributesToPush.push('systemMode');
+    }
+    else {
+        attributesToSkip.push('systemMode');
+    }
+    if (snapshot.currentTemperatureCelsius !== undefined) {
+        attributesToPush.push('currentTemp');
+    }
+    else if (snapshot.has(KEY_TEMP_CURRENT)) {
+        attributesToSkip.push('currentTemp');
+    }
+    if (snapshot.targetTemperatureCelsius !== undefined) {
+        attributesToPush.push('targetTemp');
+    }
+    else if (snapshot.has(KEY_TEMP_TARGET)) {
+        attributesToSkip.push('targetTemp');
+    }
+    if (snapshot.has(KEY_WIND_STRENGTH)) {
+        attributesToPush.push('fanSpeed');
+    }
+    else if (capabilities.supportsFanSpeedControl) {
+        attributesToSkip.push('fanSpeed');
+    }
+    logger.debug(`applyThinqSnapshotToAirConditioner: entry for deviceId=${deviceId}, pushing ${attributesToPush.length} attributes: ${attributesToPush.join(', ')}`);
+    if (attributesToSkip.length > 0) {
+        logger.debug(`applyThinqSnapshotToAirConditioner: skipped (source key absent): ${attributesToSkip.join(', ')}`);
+    }
+    if (hasPower) {
+        await airConditioner.updateAttribute(OnOff.id, 'onOff', snapshot.isPowerOn, logger);
+    }
+    const currentTemperatureCelsius = snapshot.currentTemperatureCelsius;
+    if (currentTemperatureCelsius !== undefined) {
+        await airConditioner.updateAttribute(TemperatureMeasurement.id, 'measuredValue', currentTemperatureCelsius * 100, logger);
+        await airConditioner.updateAttribute(Thermostat.id, 'localTemperature', currentTemperatureCelsius * 100, logger);
+    }
+    const targetTemperatureCelsius = snapshot.targetTemperatureCelsius;
+    if (targetTemperatureCelsius !== undefined) {
+        await airConditioner.updateAttribute(Thermostat.id, 'occupiedCoolingSetpoint', targetTemperatureCelsius * 100, logger);
+        if (capabilities.supportsHeat) {
+            await airConditioner.updateAttribute(Thermostat.id, 'occupiedHeatingSetpoint', targetTemperatureCelsius * 100, logger);
+        }
+    }
+    if (systemModeUpdate !== undefined) {
+        await airConditioner.updateAttribute(Thermostat.id, 'systemMode', systemModeUpdate, logger);
+    }
+    if (snapshot.has(KEY_WIND_STRENGTH)) {
+        if (capabilities.supportsFanSpeedControl) {
+            await airConditioner.updateAttribute(FanControl.id, 'fanMode', mapWindStrengthToFanMode(snapshot.windStrength), logger);
+            const percentCurrent = mapWindStrengthToPercent(snapshot.windStrength);
+            if (percentCurrent !== undefined) {
+                await airConditioner.updateAttribute(FanControl.id, 'percentCurrent', percentCurrent, logger);
+            }
+        }
+        else {
+            await airConditioner.updateAttribute(FanControl.id, 'fanMode', mapWindStrengthToFixedFanMode(snapshot.windStrength), logger);
+        }
+    }
+    if (capabilities.supportsFanSpeedControl && capabilities.supportsSwingMode && rockSetting !== undefined) {
+        await airConditioner.updateAttribute(FanControl.id, 'rockSetting', rockSetting, logger);
+    }
+    if (capabilities.supportsHumiditySensor) {
+        const humidityPercent = snapshot.humidityPercent;
+        if (humidityPercent !== undefined) {
+            const humiditySensorChild = airConditioner.getChildEndpointById('HumiditySensor');
+            if (humiditySensorChild) {
+                await humiditySensorChild.updateAttribute(RelativeHumidityMeasurement.id, 'measuredValue', humidityPercent * 100, logger);
+            }
+        }
+    }
+    if (capabilities.supportsAirQualitySensor) {
+        const airQualitySensorChild = airConditioner.getChildEndpointById('AirQualitySensor');
+        if (airQualitySensorChild) {
+            const airQualityOverall = snapshot.airQualityOverall;
+            if (airQualityOverall !== undefined) {
+                await airQualitySensorChild.updateAttribute(AirQuality.id, 'airQuality', airQualityOverall, logger);
+            }
+            const pm25Value = snapshot.pm25;
+            if (pm25Value !== undefined) {
+                await airQualitySensorChild.updateAttribute(Pm25ConcentrationMeasurement.id, 'measuredValue', pm25Value, logger);
+            }
+            const pm10Value = snapshot.pm10;
+            if (pm10Value !== undefined) {
+                await airQualitySensorChild.updateAttribute(Pm10ConcentrationMeasurement.id, 'measuredValue', pm10Value, logger);
+            }
+        }
+    }
+    if (capabilities.supportsEnergyMonitoring) {
+        const watts = isKnownOff(airConditioner, snapshot) ? 0 : snapshot.powerConsumptionWatts;
+        if (watts !== undefined) {
+            await airConditioner.updateAttribute(ElectricalPowerMeasurement.id, 'activePower', Math.round(watts * 1000), logger);
+        }
+    }
+}

package/dist/platform/thinq/thinqDeviceConfigReconciler.js

@@ -0,0 +1,26 @@
+import { isAirConditionerDevice, isWasherDevice } from '../../core/domain/entities/ThinqDevice.js';
+export function reconcileThinqDeviceConfigEntries(configDevices, discoveredDevices) {
+    let changed = false;
+    for (const discovered of discoveredDevices) {
+        let deviceType;
+        if (isAirConditionerDevice(discovered)) {
+            deviceType = 'AC';
+        }
+        else if (isWasherDevice(discovered)) {
+            deviceType = 'WASHER';
+        }
+        else {
+            continue;
+        }
+        const existingEntry = configDevices.find((d) => d.deviceId === discovered.id);
+        if (!existingEntry) {
+            configDevices.push({ deviceId: discovered.id, deviceType });
+            changed = true;
+        }
+        else if (existingEntry.deviceType !== deviceType) {
+            existingEntry.deviceType = deviceType;
+            changed = true;
+        }
+    }
+    return changed;
+}

package/dist/platform/thinq/thinqDeviceConfigurator.js

@@ -0,0 +1,124 @@
+import { FanControl } from 'matterbridge/matter/clusters';
+import { registerAirConditionerCommandHandlers, THINQ_FAN_SPEED_AUTO, THINQ_FAN_SPEED_LOW, THINQ_FAN_SPEED_MEDIUM, } from './thinqAirConditionerCommandHandlers.js';
+import { buildAirConditionerEndpoint } from './thinqAirConditionerEndpointFactory.js';
+import { registerFilterResetCommandHandler } from './thinqAirConditionerFilterResetCommandHandler.js';
+import { registerWasherCommandHandlers } from './thinqWasherCommandHandlers.js';
+import { buildWasherEndpoint } from './thinqWasherEndpointFactory.js';
+import { extractWasherStopCommand } from './thinqWasherStopCommandResolver.js';
+const DEFAULT_TEMPERATURE_CELSIUS = 20;
+const MAX_HEAT_SETPOINT_LIMIT_CELSIUS = 30;
+const MIN_COOL_SETPOINT_LIMIT_CELSIUS = 18;
+const DEFAULT_PRODUCT_IDENTITY = {
+    AC: { productId: 0x8000, productName: 'LG Air Conditioner' },
+    WASHER: { productId: 0x8001, productName: 'LG Washer' },
+};
+export function mapWindStrengthToFanMode(windStrength) {
+    if (windStrength === undefined || windStrength === THINQ_FAN_SPEED_AUTO) {
+        return FanControl.FanMode.Auto;
+    }
+    if (windStrength <= THINQ_FAN_SPEED_LOW) {
+        return FanControl.FanMode.Low;
+    }
+    if (windStrength <= THINQ_FAN_SPEED_MEDIUM) {
+        return FanControl.FanMode.Medium;
+    }
+    return FanControl.FanMode.High;
+}
+export function mapWindStrengthToFixedFanMode(windStrength) {
+    return windStrength === undefined ? FanControl.FanMode.Off : FanControl.FanMode.High;
+}
+export class ThinqDeviceConfigurator {
+    logger;
+    apiClient;
+    configManager;
+    constructor(logger, apiClient, configManager) {
+        this.logger = logger;
+        this.apiClient = apiClient;
+        this.configManager = configManager;
+    }
+    resolveProductIdentity(device) {
+        const productIdOverride = this.configManager.getProductIdForDevice(device.id);
+        const productNameOverride = this.configManager.getProductNameForDevice(device.id);
+        const defaultIdentity = DEFAULT_PRODUCT_IDENTITY[device.type];
+        return {
+            productId: productIdOverride ?? defaultIdentity.productId,
+            productName: productNameOverride ?? defaultIdentity.productName,
+        };
+    }
+    async registerAirConditioner(device) {
+        const snapshot = device.snapshot;
+        const currentTemperature = snapshot.currentTemperatureCelsius ?? DEFAULT_TEMPERATURE_CELSIUS;
+        const targetTemperature = snapshot.targetTemperatureCelsius ?? DEFAULT_TEMPERATURE_CELSIUS;
+        const capabilities = this.configManager.getDeviceCapabilities(device.id);
+        this.logger.debug(`registerAirConditioner: entry for deviceId=${device.id}`);
+        this.logger.info(`Registering ThinQ AirConditioner: ${device.name} (${device.id})`);
+        const initialFanMode = capabilities.supportsFanSpeedControl
+            ? mapWindStrengthToFanMode(snapshot.windStrength)
+            : mapWindStrengthToFixedFanMode(snapshot.windStrength);
+        const matterOverride = this.configManager.overrideMatterConfiguration
+            ? this.configManager.matterOverrideSettings
+            : undefined;
+        const productIdentity = this.resolveProductIdentity(device);
+        const airConditioner = buildAirConditionerEndpoint(device, capabilities, {
+            currentTemperature,
+            targetTemperature,
+            minHeatSetpointLimitCelsius: 0,
+            maxHeatSetpointLimitCelsius: MAX_HEAT_SETPOINT_LIMIT_CELSIUS,
+            minCoolSetpointLimitCelsius: MIN_COOL_SETPOINT_LIMIT_CELSIUS,
+            maxCoolSetpointLimitCelsius: 50,
+        }, initialFanMode, {
+            vendorId: matterOverride?.matterVendorId,
+            vendorName: matterOverride?.matterVendorName,
+            productId: productIdentity.productId,
+            productName: productIdentity.productName,
+        })
+            .createDefaultTemperatureMeasurementClusterServer(currentTemperature * 100)
+            .addRequiredClusterServers();
+        airConditioner.mode = 'server';
+        registerAirConditionerCommandHandlers(airConditioner, device, this.apiClient, this.logger, capabilities);
+        const filterResetControl = this.configManager.getAcFilterControlConfig(device.id);
+        registerFilterResetCommandHandler(airConditioner, device, this.apiClient, this.logger, capabilities, filterResetControl);
+        this.logger.debug(`registerAirConditioner: completed for deviceId=${device.id}`);
+        return Promise.resolve(airConditioner);
+    }
+    async registerWasher(device) {
+        this.logger.debug(`registerWasher: entry for deviceId=${device.id}`);
+        this.logger.info(`Registering ThinQ Washer: ${device.name} (${device.id})`);
+        const matterOverride = this.configManager.overrideMatterConfiguration
+            ? this.configManager.matterOverrideSettings
+            : undefined;
+        const productIdentity = this.resolveProductIdentity(device);
+        const washer = buildWasherEndpoint(device, {
+            vendorId: matterOverride?.matterVendorId,
+            vendorName: matterOverride?.matterVendorName,
+            productId: productIdentity.productId,
+            productName: productIdentity.productName,
+        });
+        washer.mode = 'server';
+        const washerControl = this.configManager.getWasherControlConfig(device.id);
+        const stopCommandPayload = await this.resolveWasherStopCommandPayload(device);
+        registerWasherCommandHandlers(washer, device, this.apiClient, this.logger, washerControl, stopCommandPayload);
+        this.logger.debug(`registerWasher: completed for deviceId=${device.id}`);
+        return washer;
+    }
+    async resolveWasherStopCommandPayload(device) {
+        if (!device.modelJsonUri) {
+            return undefined;
+        }
+        try {
+            const model = await this.apiClient.getDeviceModel(device.modelJsonUri);
+            const payload = extractWasherStopCommand(model);
+            if (payload) {
+                this.logger.info(`ThinQ Washer ${device.id}: resolved stop-command payload from device model: ${JSON.stringify(payload)}`);
+            }
+            else {
+                this.logger.info(`ThinQ Washer ${device.id}: device model has no WMStop/WMOff entry.`);
+            }
+            return payload;
+        }
+        catch (error) {
+            this.logger.debug(`ThinQ Washer ${device.id}: failed to resolve stop-command payload from device model: ${error instanceof Error ? error.message : String(error)}`);
+            return undefined;
+        }
+    }
+}