matterbridge-lg-thinq-plugin 0.1.0

package/dist/core/domain/value-objects/AirConditionerCapabilities.js

@@ -0,0 +1,22 @@
+export const DEFAULT_AIR_CONDITIONER_CAPABILITIES = {
+    supportsHeat: true,
+    supportsFanSpeedControl: true,
+    supportsSwingMode: false,
+    supportsHumiditySensor: false,
+    supportsAirQualitySensor: false,
+    supportsEnergyMonitoring: false,
+    supportsFilterMonitoring: false,
+};
+export function resolveAirConditionerCapabilities(devices, deviceId) {
+    const entry = devices?.find((device) => device.deviceId === deviceId);
+    const capabilities = entry?.capabilities;
+    return {
+        supportsHeat: capabilities?.supportsHeat ?? DEFAULT_AIR_CONDITIONER_CAPABILITIES.supportsHeat,
+        supportsFanSpeedControl: capabilities?.supportsFanSpeedControl ?? DEFAULT_AIR_CONDITIONER_CAPABILITIES.supportsFanSpeedControl,
+        supportsSwingMode: capabilities?.supportsSwingMode ?? DEFAULT_AIR_CONDITIONER_CAPABILITIES.supportsSwingMode,
+        supportsHumiditySensor: capabilities?.supportsHumiditySensor ?? DEFAULT_AIR_CONDITIONER_CAPABILITIES.supportsHumiditySensor,
+        supportsAirQualitySensor: capabilities?.supportsAirQualitySensor ?? DEFAULT_AIR_CONDITIONER_CAPABILITIES.supportsAirQualitySensor,
+        supportsEnergyMonitoring: capabilities?.supportsEnergyMonitoring ?? DEFAULT_AIR_CONDITIONER_CAPABILITIES.supportsEnergyMonitoring,
+        supportsFilterMonitoring: capabilities?.supportsFilterMonitoring ?? DEFAULT_AIR_CONDITIONER_CAPABILITIES.supportsFilterMonitoring,
+    };
+}

package/dist/core/domain/value-objects/ThinqFilterState.js

@@ -0,0 +1,35 @@
+const KEY_USE_TIME = 'airState.filterMngStates.useTime';
+const KEY_MAX_TIME = 'airState.filterMngStates.maxTime';
+const KEY_CHANGE_DATE = 'airState.filterMngStates.changeDate';
+export class ThinqFilterState {
+    useTimeHours;
+    maxTimeHours;
+    changeDateRaw;
+    constructor(useTimeHours, maxTimeHours, changeDateRaw) {
+        this.useTimeHours = useTimeHours;
+        this.maxTimeHours = maxTimeHours;
+        this.changeDateRaw = changeDateRaw;
+    }
+    static fromRaw(data) {
+        const useTimeHours = readNumber(data, KEY_USE_TIME);
+        const maxTimeHours = readNumber(data, KEY_MAX_TIME);
+        if (useTimeHours === undefined || maxTimeHours === undefined || maxTimeHours <= 0) {
+            return undefined;
+        }
+        return new ThinqFilterState(useTimeHours, maxTimeHours, readNumber(data, KEY_CHANGE_DATE));
+    }
+    get remainingPercent() {
+        const percent = ((this.maxTimeHours - this.useTimeHours) / this.maxTimeHours) * 100;
+        return Math.max(0, Math.min(100, Math.round(percent)));
+    }
+    get changeDate() {
+        return this.changeDateRaw;
+    }
+    get ratedMaxTimeHours() {
+        return this.maxTimeHours;
+    }
+}
+function readNumber(data, key) {
+    const value = data?.[key];
+    return typeof value === 'number' ? value : undefined;
+}

package/dist/core/domain/value-objects/ThinqSnapshot.js

@@ -0,0 +1,125 @@
+const WASHER_NOT_RUNNING_STATES = [
+    'COOLDOWN',
+    'POWEROFF',
+    'POWERFAIL',
+    'INITIAL',
+    'PAUSE',
+    'AUDIBLE_DIAGNOSIS',
+    'FIRMWARE',
+    'COURSE_DOWNLOAD',
+    'ERROR',
+    'END',
+];
+export class ThinqSnapshot {
+    data;
+    constructor(data) {
+        this.data = data;
+    }
+    get raw() {
+        return this.data;
+    }
+    has(key) {
+        const value = this.data[key];
+        return value !== undefined && value !== null;
+    }
+    get isPowerOn() {
+        return Number(this.data['airState.operation']) === 1;
+    }
+    get currentTemperatureCelsius() {
+        return this.readNumber('airState.tempState.current');
+    }
+    get targetTemperatureCelsius() {
+        return this.readNumber('airState.tempState.target');
+    }
+    get operationMode() {
+        return this.readNumber('airState.opMode');
+    }
+    get windStrength() {
+        return this.readNumber('airState.windStrength');
+    }
+    get online() {
+        return typeof this.data.online === 'boolean' ? this.data.online : undefined;
+    }
+    get isJetModeOn() {
+        return Number(this.data['airState.wMode.jet']) === 1;
+    }
+    get isQuietModeOn() {
+        return Number(this.data['airState.miscFuncState.silentAWHP']) === 1;
+    }
+    get isEnergySaveModeOn() {
+        return Number(this.data['airState.powerSave.basic']) === 1;
+    }
+    get isAirCleanModeOn() {
+        return Number(this.data['airState.wMode.airClean']) === 1;
+    }
+    get isLedOn() {
+        return Number(this.data['airState.lightingState.displayControl']) === 1;
+    }
+    get isVerticalSwingOn() {
+        return Number(this.data['airState.wDir.vStep']) === 100;
+    }
+    get isHorizontalSwingOn() {
+        return Number(this.data['airState.wDir.hStep']) === 100;
+    }
+    get humidityPercent() {
+        const value = this.readNumber('airState.humidity.current');
+        if (value === undefined) {
+            return undefined;
+        }
+        return value > 100 ? value / 10 : value;
+    }
+    get airQualityOverall() {
+        return this.readNumber('airState.quality.overall');
+    }
+    get pm25() {
+        return this.readNumber('airState.quality.PM2');
+    }
+    get pm10() {
+        return this.readNumber('airState.quality.PM10');
+    }
+    get powerConsumptionWatts() {
+        const value = this.readNumber('airState.energy.onCurrent');
+        return value === undefined || Number.isNaN(value) ? undefined : value;
+    }
+    get washerDryer() {
+        const value = this.data['washerDryer'];
+        return typeof value === 'object' && value !== null ? value : undefined;
+    }
+    get hasWasherDryer() {
+        return this.washerDryer !== undefined;
+    }
+    get washerRawState() {
+        const value = this.washerDryer?.['state'];
+        return typeof value === 'string' ? value : undefined;
+    }
+    get isWasherPowerOn() {
+        return this.washerRawState !== undefined && !['POWEROFF', 'POWERFAIL'].includes(this.washerRawState);
+    }
+    get isWasherRunning() {
+        return (this.isWasherPowerOn &&
+            this.washerRawState !== undefined &&
+            !WASHER_NOT_RUNNING_STATES.includes(this.washerRawState));
+    }
+    get isWasherError() {
+        return this.washerRawState === 'ERROR';
+    }
+    get washerRemainingDurationSeconds() {
+        const hours = this.readWasherNumber('remainTimeHour');
+        const minutes = this.readWasherNumber('remainTimeMinute');
+        if (hours === undefined && minutes === undefined) {
+            return undefined;
+        }
+        if (!this.isWasherRunning) {
+            return 0;
+        }
+        return (hours ?? 0) * 3600 + (minutes ?? 0) * 60;
+    }
+    readNumber(key) {
+        const value = this.data[key];
+        return typeof value === 'number' ? value : undefined;
+    }
+    readWasherNumber(key) {
+        const value = this.washerDryer?.[key];
+        return typeof value === 'number' ? value : undefined;
+    }
+}

package/dist/errors/AuthenticationError.js

@@ -0,0 +1,26 @@
+import { BaseError } from './BaseError.js';
+export class AuthenticationError extends BaseError {
+    constructor(message, metadata) {
+        super(message, 'THINQ_AUTH_ERROR', 401, metadata);
+    }
+}
+export class InvalidCredentialsError extends AuthenticationError {
+    constructor(username) {
+        super('Invalid LG ThinQ username or password. Please check your credentials.', {
+            reason: 'INVALID_CREDENTIALS',
+            username,
+        });
+    }
+}
+export class TokenExpiredError extends AuthenticationError {
+    constructor() {
+        super('LG ThinQ authentication token has expired. Please log in again.', {
+            reason: 'TOKEN_EXPIRED',
+        });
+    }
+}
+export class ManualProcessNeededError extends BaseError {
+    constructor(message = 'LG ThinQ requires a manual process (e.g. accepting new terms in the native LG app) before continuing.', metadata) {
+        super(message, 'MANUAL_PROCESS_NEEDED', 428, metadata);
+    }
+}

package/dist/errors/BaseError.js

@@ -0,0 +1,23 @@
+export class BaseError extends Error {
+    code;
+    statusCode;
+    metadata;
+    constructor(message, code, statusCode, metadata) {
+        super(message);
+        this.code = code;
+        this.statusCode = statusCode;
+        this.metadata = metadata;
+        this.name = this.constructor.name;
+        Error.captureStackTrace(this, this.constructor);
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            code: this.code,
+            statusCode: this.statusCode,
+            metadata: this.metadata,
+            stack: this.stack,
+        };
+    }
+}

package/dist/errors/index.js

@@ -0,0 +1,2 @@
+export { BaseError } from './BaseError.js';
+export { AuthenticationError, InvalidCredentialsError, ManualProcessNeededError, TokenExpiredError, } from './AuthenticationError.js';

package/dist/model/LgThinkqPluginPlatformConfig.js

@@ -0,0 +1,23 @@
+export function createDefaultAdvancedFeature() {
+    return {
+        settings: {
+            debug: false,
+            clearStorageOnStartup: false,
+            forceAuthentication: false,
+            unregisterOnShutdown: false,
+            overrideMatterConfiguration: false,
+            matterOverrideSettings: {
+                matterVendorName: 'Matterbridge',
+                matterVendorId: 0xfff1,
+            },
+        },
+    };
+}
+export function createDefaultThinqConfig() {
+    return {
+        loginType: 'account',
+        country: 'US',
+        language: 'en-US',
+        devices: [],
+    };
+}

package/dist/model/LgThinqPluginPlatformConfig.js

@@ -0,0 +1,23 @@
+export function createDefaultAdvancedFeature() {
+    return {
+        settings: {
+            debug: false,
+            clearStorageOnStartup: false,
+            forceAuthentication: false,
+            unregisterOnShutdown: false,
+            overrideMatterConfiguration: false,
+            matterOverrideSettings: {
+                matterVendorName: 'Matterbridge',
+                matterVendorId: 0xfff1,
+            },
+        },
+    };
+}
+export function createDefaultThinqConfig() {
+    return {
+        loginType: 'account',
+        country: 'US',
+        language: 'en-US',
+        devices: [],
+    };
+}

package/dist/module.js

@@ -0,0 +1,212 @@
+import Path from 'node:path';
+import { MatterbridgeDynamicPlatform } from 'matterbridge';
+import NodePersist from 'node-persist';
+import { UNREGISTER_DEVICES_DELAY_MS } from './constants/index.js';
+import { isAirConditionerDevice, isWasherDevice } from './core/domain/entities/ThinqDevice.js';
+import { ManualProcessNeededError } from './errors/index.js';
+import { DeviceRegistry } from './platform/deviceRegistry.js';
+import { PlatformConfigManager } from './platform/platformConfigManager.js';
+import { PlatformState } from './platform/platformState.js';
+import { applyThinqFilterStateToAirConditioner } from './platform/thinq/thinqAirConditionerFilterStateSync.js';
+import { applyThinqSnapshotToAirConditioner } from './platform/thinq/thinqAirConditionerStateSync.js';
+import { reconcileThinqDeviceConfigEntries } from './platform/thinq/thinqDeviceConfigReconciler.js';
+import { applyThinqSnapshotToWasher } from './platform/thinq/thinqWasherStateSync.js';
+import { ThinqServiceContainer } from './services/thinq/serviceContainer.js';
+import { ThinqSession } from './services/thinq/session.js';
+import { PLUGIN_NAME } from './settings.js';
+export default function initializePlugin(matterbridge, log, config) {
+    return new LgThinqMatterbridgePlatform(matterbridge, log, config);
+}
+export class LgThinqMatterbridgePlatform extends MatterbridgeDynamicPlatform {
+    config;
+    persist;
+    registry;
+    configManager;
+    state;
+    thinqServices;
+    thinqPollingIntervalMs;
+    thinqDeviceKindById = new Map();
+    filterMonitoringDeviceIds = [];
+    constructor(matterbridge, logger, config) {
+        super(matterbridge, logger, config);
+        this.config = config;
+        logger.logLevel = this.config.advancedFeature.settings.debug ? "debug" : "info";
+        this.log.info('Initializing platform:', this.config.name);
+        const persistDir = Path.join(this.matterbridge.matterbridgePluginDirectory, PLUGIN_NAME, 'persist');
+        this.persist = NodePersist.create({ dir: persistDir });
+        this.configManager = PlatformConfigManager.create(config, this.log);
+        this.registry = new DeviceRegistry();
+        this.state = new PlatformState();
+        this.thinqServices = new ThinqServiceContainer(this.log, this.persist, this.configManager, Path.join(this.matterbridge.matterbridgePluginDirectory, PLUGIN_NAME, 'mqtt-certs'));
+    }
+    async onStart(reason) {
+        this.log.debug(`onStart: entry (reason=${reason ?? 'none'})`);
+        this.log.notice('onStart called with reason:', reason ?? 'none');
+        await this.ready;
+        await this.clearSelect();
+        await this.persist.init();
+        if (this.configManager.isClearStorageOnStartupEnabled) {
+            this.log.debug('onStart: exit early — clear-storage-on-startup enabled, skipping device startup');
+            return;
+        }
+        if (!this.configManager.validateConfig()) {
+            this.log.error('Platform configuration is invalid.');
+            this.state.setStartupCompleted(false);
+            this.log.debug('onStart: exit — invalid platform configuration');
+            return;
+        }
+        try {
+            await this.startThinqDevices();
+        }
+        catch (error) {
+            this.log.error(`ThinQ startup failed: ${error instanceof Error ? error.message : String(error)}`);
+            this.state.setStartupCompleted(false);
+            this.log.debug('onStart: exit — ThinQ startup threw');
+            return;
+        }
+        this.log.notice('onStart finished');
+        this.state.setStartupCompleted(true);
+        this.log.debug('onStart: exit — startup completed successfully');
+    }
+    async onConfigure() {
+        await super.onConfigure();
+        this.log.debug('onConfigure: entry');
+        this.log.notice('onConfigure called');
+        if (this.configManager.isClearStorageOnStartupEnabled) {
+            this.log.warn('Clearing persistence storage as per configuration.');
+            await this.persist
+                .clear()
+                .then(() => this.unregisterAllDevices(UNREGISTER_DEVICES_DELAY_MS))
+                .then(() => {
+                this.log.notice('Please restart the platform now.');
+                this.wssSendRestartRequired();
+            })
+                .catch((error) => {
+                this.log.error(`Error clearing persistence storage: ${error}`);
+            });
+            this.log.debug('onConfigure: exit early — clear-storage-on-startup enabled');
+            return;
+        }
+        if (!this.state.isStartupCompleted) {
+            this.log.debug('onConfigure: exit early — startup did not complete, skipping polling setup');
+            return;
+        }
+        const applyDeviceUpdate = (deviceId, snapshot) => {
+            const endpoint = this.registry.getDevice(deviceId);
+            if (!endpoint) {
+                this.log.debug(`ThinQ device update received for unregistered device ${deviceId}, skipping.`);
+                return;
+            }
+            if (this.thinqDeviceKindById.get(deviceId) === 'WASHER') {
+                void applyThinqSnapshotToWasher(endpoint, snapshot, this.log).catch((error) => {
+                    this.log.error(`Failed to apply ThinQ state update for ${deviceId}: ${error instanceof Error ? error.message : String(error)}`);
+                });
+                return;
+            }
+            void applyThinqSnapshotToAirConditioner(endpoint, snapshot, this.configManager.getDeviceCapabilities(deviceId), this.log).catch((error) => {
+                this.log.error(`Failed to apply ThinQ state update for ${deviceId}: ${error instanceof Error ? error.message : String(error)}`);
+            });
+        };
+        this.thinqPollingIntervalMs = this.configManager.thinqRefreshIntervalSeconds * 1000;
+        this.thinqServices.getDeviceService().startPolling(this.thinqPollingIntervalMs, applyDeviceUpdate);
+        this.thinqServices.getDeviceService().startKeepAlive();
+        void this.thinqServices
+            .getMqttListener()
+            .start(applyDeviceUpdate)
+            .catch((error) => {
+            this.log.error(`ThinQ MQTT listener failed to start: ${error instanceof Error ? error.message : String(error)}`);
+        });
+        if (this.filterMonitoringDeviceIds.length > 0) {
+            const applyFilterUpdate = (deviceId, filterState) => {
+                const endpoint = this.registry.getDevice(deviceId);
+                if (!endpoint) {
+                    this.log.debug(`ThinQ filter update received for unregistered device ${deviceId}, skipping.`);
+                    return;
+                }
+                void applyThinqFilterStateToAirConditioner(endpoint, filterState, this.log).catch((error) => {
+                    this.log.error(`Failed to apply ThinQ filter state update for ${deviceId}: ${error instanceof Error ? error.message : String(error)}`);
+                });
+            };
+            const filterMonitoringIntervalMs = this.configManager.thinqFilterMonitoringIntervalSeconds * 1000;
+            this.thinqServices
+                .getFilterMonitoringService()
+                .startPolling(filterMonitoringIntervalMs, this.filterMonitoringDeviceIds, applyFilterUpdate);
+        }
+        this.log.debug(`onConfigure: exit — polling started at ${this.thinqPollingIntervalMs}ms interval`);
+    }
+    async onShutdown(reason) {
+        await super.onShutdown(reason);
+        this.log.debug(`onShutdown: entry (reason=${reason ?? 'none'})`);
+        this.log.notice('onShutdown called with reason:', reason ?? 'none');
+        this.thinqServices.getDeviceService().stopPolling();
+        this.thinqServices.getDeviceService().stopKeepAlive();
+        this.thinqServices.getMqttListener().stop();
+        this.thinqServices.getFilterMonitoringService().stopPolling();
+        if (this.configManager.unregisterOnShutdown) {
+            await this.unregisterAllDevices(UNREGISTER_DEVICES_DELAY_MS);
+        }
+        this.state.setStartupCompleted(false);
+        this.log.debug('onShutdown: exit');
+    }
+    async startThinqDevices() {
+        const userDataRepository = this.thinqServices.getUserDataRepository();
+        let userData = this.configManager.isForceAuthenticationEnabled
+            ? undefined
+            : await userDataRepository.loadUserData();
+        if (!userData) {
+            userData = await this.thinqServices
+                .getAuthenticationCoordinator()
+                .authenticate(this.configManager.thinqLoginType, {
+                username: this.configManager.thinqUsername,
+                password: this.configManager.thinqPassword,
+                refreshToken: this.configManager.thinqRefreshToken,
+                country: this.configManager.country,
+                language: this.configManager.language,
+            });
+        }
+        if (!userData) {
+            throw new ManualProcessNeededError('LG ThinQ authentication did not return user data. This account likely uses a third-party SSO login ' +
+                '(Google/Apple/Facebook/Amazon), which is not yet supported headlessly — please log in with a native ' +
+                'LG account (email/password) or refresh token instead.', { reason: 'THIRD_PARTY_SSO_NOT_SUPPORTED' });
+        }
+        this.thinqServices.apiClient.setSession(ThinqSession.fromData(userData));
+        if (userData.userNumber) {
+            this.thinqServices.apiClient.setUserNumber(userData.userNumber);
+        }
+        await userDataRepository.saveUserData(userData);
+        const devices = await this.thinqServices.getDeviceDiscovery().discoverDevices();
+        const configChanged = reconcileThinqDeviceConfigEntries(this.config.thinq.devices, devices);
+        if (configChanged) {
+            try {
+                this.saveConfig(this.config);
+            }
+            catch (error) {
+                this.log.error(`Failed to persist auto-populated ThinQ device config: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        const configurator = this.thinqServices.getDeviceConfigurator();
+        for (const device of devices) {
+            if (isAirConditionerDevice(device)) {
+                const airConditioner = await configurator.registerAirConditioner(device);
+                await this.registerDevice(airConditioner);
+                this.registry.register(device.id, airConditioner);
+                this.thinqDeviceKindById.set(device.id, 'AC');
+                if (this.configManager.getDeviceCapabilities(device.id).supportsFilterMonitoring) {
+                    this.filterMonitoringDeviceIds.push(device.id);
+                }
+                continue;
+            }
+            if (isWasherDevice(device)) {
+                const washer = await configurator.registerWasher(device);
+                await this.registerDevice(washer);
+                this.registry.register(device.id, washer);
+                this.thinqDeviceKindById.set(device.id, 'WASHER');
+                continue;
+            }
+        }
+    }
+    async onChangeLoggerLevel(logLevel) {
+        this.log.notice(`Change ${PLUGIN_NAME} log level: ${logLevel} (was ${this.log.logLevel})`);
+        this.log.logLevel = logLevel;
+    }
+}

package/dist/platform/deviceRegistry.js

@@ -0,0 +1,26 @@
+export class DeviceRegistry {
+    devices = new Map();
+    register(deviceId, device) {
+        if (!deviceId)
+            return;
+        this.devices.set(deviceId, device);
+    }
+    unregister(deviceId) {
+        this.devices.delete(deviceId);
+    }
+    getDevice(deviceId) {
+        return this.devices.get(deviceId);
+    }
+    getAllDevices() {
+        return Array.from(this.devices.values());
+    }
+    get size() {
+        return this.devices.size;
+    }
+    hasDevices() {
+        return this.devices.size > 0;
+    }
+    clear() {
+        this.devices.clear();
+    }
+}

package/dist/platform/platformConfigManager.js

@@ -0,0 +1,89 @@
+import { resolveAirConditionerCapabilities } from '../core/domain/value-objects/AirConditionerCapabilities.js';
+import { createDefaultAdvancedFeature, createDefaultThinqConfig, } from '../model/LgThinqPluginPlatformConfig.js';
+const DEFAULT_THINQ_REFRESH_INTERVAL_SECONDS = 60;
+const DEFAULT_FILTER_MONITORING_INTERVAL_SECONDS = 3600;
+export class PlatformConfigManager {
+    config;
+    log;
+    constructor(config, log) {
+        this.config = config;
+        this.log = log;
+        this.config.thinq ??= createDefaultThinqConfig();
+        this.config.webos ??= { devices: [] };
+        this.config.advancedFeature ??= createDefaultAdvancedFeature();
+    }
+    static create(config, log) {
+        return new PlatformConfigManager(config, log);
+    }
+    get rawConfig() {
+        return this.config;
+    }
+    get debug() {
+        return this.config.advancedFeature.settings.debug;
+    }
+    get isClearStorageOnStartupEnabled() {
+        return this.config.advancedFeature.settings.clearStorageOnStartup;
+    }
+    get isForceAuthenticationEnabled() {
+        return this.config.advancedFeature.settings.forceAuthentication;
+    }
+    get unregisterOnShutdown() {
+        return this.config.advancedFeature.settings.unregisterOnShutdown;
+    }
+    get thinqLoginType() {
+        return this.config.thinq.loginType;
+    }
+    get thinqUsername() {
+        return this.config.thinq.username;
+    }
+    get thinqPassword() {
+        return this.config.thinq.password;
+    }
+    get thinqRefreshToken() {
+        return this.config.thinq.refreshToken;
+    }
+    get country() {
+        return this.config.thinq.country;
+    }
+    get language() {
+        return this.config.thinq.language;
+    }
+    get thinqRefreshIntervalSeconds() {
+        return this.config.thinq.refreshIntervalSeconds ?? DEFAULT_THINQ_REFRESH_INTERVAL_SECONDS;
+    }
+    get thinqFilterMonitoringIntervalSeconds() {
+        return this.config.thinq.filterMonitoringIntervalSeconds ?? DEFAULT_FILTER_MONITORING_INTERVAL_SECONDS;
+    }
+    getDeviceCapabilities(deviceId) {
+        return resolveAirConditionerCapabilities(this.config.thinq.devices, deviceId);
+    }
+    getWasherControlConfig(deviceId) {
+        return this.config.thinq.devices?.find((d) => d.deviceId === deviceId)?.washerControl ?? {};
+    }
+    getAcFilterControlConfig(deviceId) {
+        return this.config.thinq.devices?.find((d) => d.deviceId === deviceId)?.acFilterControl ?? {};
+    }
+    get overrideMatterConfiguration() {
+        return this.config.advancedFeature.settings.overrideMatterConfiguration;
+    }
+    get matterOverrideSettings() {
+        return this.config.advancedFeature.settings.matterOverrideSettings;
+    }
+    getProductNameForDevice(deviceId) {
+        if (!this.overrideMatterConfiguration)
+            return undefined;
+        return this.config.thinq.devices?.find((d) => d.deviceId === deviceId)?.productName;
+    }
+    getProductIdForDevice(deviceId) {
+        if (!this.overrideMatterConfiguration)
+            return undefined;
+        return this.config.thinq.devices?.find((d) => d.deviceId === deviceId)?.productId;
+    }
+    validateConfig() {
+        this.log.debug('Validating platform config');
+        if (this.thinqLoginType === 'token') {
+            return Boolean(this.thinqRefreshToken);
+        }
+        return Boolean(this.thinqUsername && this.thinqPassword);
+    }
+}

package/dist/platform/platformState.js

@@ -0,0 +1,9 @@
+export class PlatformState {
+    startupCompleted = false;
+    get isStartupCompleted() {
+        return this.startupCompleted;
+    }
+    setStartupCompleted(completed) {
+        this.startupCompleted = completed;
+    }
+}