@smarthome.exchange/integrations 0.2.0 → 2.0.0

package/dist_ts/integrations/tasmota/tasmota.classes.runtime.js

@@ -0,0 +1,292 @@
+import * as plugins from '../../plugins.js';
+import { DeviceCommunicationError } from '../../core/errors.js';
+import { MqttClient } from '../mqtt/mqtt.classes.client.js';
+import { parseTasmotaRecord, tasmotaRecord, TasmotaMapper } from './tasmota.mapper.js';
+import { normalizeTasmotaConfig } from './tasmota.config.js';
+export class TasmotaRuntime {
+    domain = 'tasmota';
+    config;
+    client;
+    lifetime = new AbortController();
+    states = new Map();
+    listeners = new Set();
+    changed = new Set();
+    subscriptionCleanups = new Set();
+    stopConnectionListener;
+    initializing = true;
+    started = false;
+    destroyed = false;
+    destroyPromise;
+    constructor(configArg) {
+        this.config = normalizeTasmotaConfig(configArg);
+        this.client = new MqttClient(this.config.broker);
+        for (const device of this.config.devices)
+            this.states.set(device.id, { generation: 0, ready: false, online: false, queryPending: false, updatedAt: new Date(0).toISOString(), controls: {}, sensors: {} });
+        this.stopConnectionListener = this.client.onConnectionState((stateArg) => {
+            if (this.destroyed)
+                return;
+            if (!stateArg.connected) {
+                for (const device of this.config.devices)
+                    this.markOffline(device);
+            }
+            else if (!this.initializing) {
+                this.refreshInBackground(this.config.devices);
+            }
+            if (stateArg.error)
+                this.emit({ type: 'error', data: { message: stateArg.error.message } });
+        });
+    }
+    async start(abortSignalArg) {
+        this.checkActive(abortSignalArg);
+        if (this.started)
+            throw new DeviceCommunicationError('Tasmota runtime has already started.');
+        this.started = true;
+        try {
+            await this.withDeadline(async (signalArg) => {
+                await this.client.start(signalArg);
+                for (const device of this.config.devices) {
+                    await this.client.subscribe(`${device.statusBase}#`, (messageArg) => this.receive(device, messageArg), signalArg);
+                    await this.client.subscribe(`${device.telemetryBase}#`, (messageArg) => this.receive(device, messageArg), signalArg);
+                }
+                await this.refresh(this.config.devices, signalArg);
+            }, abortSignalArg);
+            this.initializing = false;
+        }
+        catch (errorArg) {
+            await this.destroy();
+            throw errorArg;
+        }
+    }
+    isHealthy() {
+        return !this.destroyed && this.client.isHealthy() && this.config.devices.every((deviceArg) => this.ready(deviceArg));
+    }
+    async devices(abortSignalArg) {
+        this.checkActive(abortSignalArg);
+        return this.config.devices.map((deviceArg) => TasmotaMapper.device(deviceArg, this.state(deviceArg), this.client.connected));
+    }
+    async entities() {
+        return (await this.devices()).flatMap((deviceArg) => TasmotaMapper.entities(deviceArg));
+    }
+    async subscribe(handlerArg, abortSignalArg) {
+        this.checkActive(abortSignalArg);
+        const listener = (eventArg) => handlerArg(eventArg);
+        this.listeners.add(listener);
+        const cleanup = () => {
+            this.listeners.delete(listener);
+            abortSignalArg?.removeEventListener('abort', cleanup);
+            this.subscriptionCleanups.delete(cleanup);
+        };
+        this.subscriptionCleanups.add(cleanup);
+        abortSignalArg?.addEventListener('abort', cleanup, { once: true });
+        return async () => cleanup();
+    }
+    async writeFeature(requestArg, abortSignalArg) {
+        this.checkActive(abortSignalArg);
+        if (requestArg.device.integrationDomain !== this.domain)
+            return { success: false, error: 'Tasmota device is not selected.' };
+        const device = this.config.devices.find((deviceArg) => deviceArg.id === requestArg.device.id);
+        if (!device)
+            return { success: false, error: 'Tasmota device is not selected.' };
+        if (!this.client.isHealthy() || !this.ready(device))
+            return { success: false, error: 'Tasmota device has no fresh online state.' };
+        const featureId = requestArg.feature.id;
+        let command;
+        let payload;
+        const relay = device.relays.find((relayArg) => featureId === `power_${relayArg}`);
+        if (relay !== undefined && typeof requestArg.value === 'boolean') {
+            command = `POWER${relay}`;
+            payload = requestArg.value ? 'ON' : 'OFF';
+        }
+        else if (featureId === 'brightness' && device.brightness && typeof requestArg.value === 'number' && Number.isInteger(requestArg.value) && requestArg.value >= 0 && requestArg.value <= 100) {
+            command = 'Dimmer';
+            payload = String(requestArg.value);
+        }
+        else {
+            return { success: false, error: 'Tasmota write requires a selected relay boolean or brightness integer from 0 through 100.' };
+        }
+        await this.client.publish({ topic: `${device.commandBase}${command}`, payload, qos: 0, retain: false }, abortSignalArg);
+        return { success: true, data: { accepted: true } };
+    }
+    destroy() {
+        if (this.destroyPromise)
+            return this.destroyPromise;
+        this.destroyed = true;
+        this.stopConnectionListener();
+        this.lifetime.abort(new DeviceCommunicationError('Tasmota runtime destroyed.'));
+        for (const cleanup of [...this.subscriptionCleanups])
+            cleanup();
+        this.listeners.clear();
+        this.changed.clear();
+        this.destroyPromise = this.client.destroy();
+        return this.destroyPromise;
+    }
+    state(deviceArg) {
+        const state = this.states.get(deviceArg.id);
+        if (!state)
+            throw new DeviceCommunicationError('Selected Tasmota device state is missing.');
+        return state;
+    }
+    ready(deviceArg) {
+        const state = this.state(deviceArg);
+        return state.ready && state.online;
+    }
+    checkActive(abortSignalArg) {
+        abortSignalArg?.throwIfAborted();
+        this.lifetime.signal.throwIfAborted();
+    }
+    async withDeadline(operationArg, abortSignalArg) {
+        const deadline = new AbortController();
+        const timer = setTimeout(() => deadline.abort(new DeviceCommunicationError('Tasmota fresh state deadline exceeded.')), this.config.initialSnapshotTimeoutMs);
+        const signal = AbortSignal.any([this.lifetime.signal, deadline.signal, ...(abortSignalArg ? [abortSignalArg] : [])]);
+        try {
+            signal.throwIfAborted();
+            return await operationArg(signal);
+        }
+        finally {
+            clearTimeout(timer);
+            deadline.abort();
+        }
+    }
+    async refresh(devicesArg, signalArg, generationsArg = new Map()) {
+        for (const device of devicesArg) {
+            const state = this.state(device);
+            state.ready = false;
+            state.queryPending = true;
+            state.generation += 1;
+            generationsArg.set(device.id, state.generation);
+        }
+        for (const handler of this.changed)
+            handler();
+        const fresh = this.waitForFresh(devicesArg, generationsArg, signalArg);
+        const queries = async () => {
+            for (const device of devicesArg) {
+                await this.client.publish({ topic: `${device.commandBase}State`, payload: '', qos: 0, retain: false }, signalArg);
+                await this.client.publish({ topic: `${device.commandBase}Status`, payload: '10', qos: 0, retain: false }, signalArg);
+            }
+        };
+        await Promise.all([fresh, queries()]);
+    }
+    refreshInBackground(devicesArg) {
+        const generations = new Map();
+        void this.withDeadline((signalArg) => this.refresh(devicesArg, signalArg, generations)).catch((errorArg) => {
+            if (this.destroyed)
+                return;
+            const currentDevices = devicesArg.filter((deviceArg) => this.state(deviceArg).generation === generations.get(deviceArg.id));
+            if (!currentDevices.length)
+                return;
+            for (const device of currentDevices)
+                this.markOffline(device);
+            this.emit({ type: 'error', data: { message: errorArg instanceof Error ? errorArg.message : 'Tasmota state refresh failed.' } });
+        });
+    }
+    waitForFresh(devicesArg, generationsArg, signalArg) {
+        return new Promise((resolve, reject) => {
+            const cleanup = () => {
+                this.changed.delete(check);
+                signalArg.removeEventListener('abort', aborted);
+            };
+            const check = () => {
+                if (devicesArg.some((deviceArg) => this.state(deviceArg).generation !== generationsArg.get(deviceArg.id))) {
+                    cleanup();
+                    reject(new DeviceCommunicationError('Tasmota state refresh superseded by a connection or availability change.'));
+                    return;
+                }
+                if (this.client.connected && devicesArg.every((deviceArg) => this.ready(deviceArg))) {
+                    cleanup();
+                    resolve();
+                }
+            };
+            const aborted = () => {
+                cleanup();
+                reject(signalArg.reason);
+            };
+            this.changed.add(check);
+            signalArg.addEventListener('abort', aborted, { once: true });
+            if (signalArg.aborted)
+                aborted();
+            else
+                check();
+        });
+    }
+    markOffline(deviceArg) {
+        const state = this.state(deviceArg);
+        const wasOnline = this.ready(deviceArg);
+        state.ready = false;
+        state.online = false;
+        state.queryPending = false;
+        state.generation += 1;
+        if (wasOnline)
+            this.emit({ type: 'availability_changed', deviceId: deviceArg.id, data: { online: false } });
+        for (const handler of this.changed)
+            handler();
+    }
+    receive(deviceArg, messageArg) {
+        if (this.destroyed)
+            return;
+        const status = messageArg.topic.startsWith(deviceArg.statusBase);
+        const suffix = messageArg.topic.slice((status ? deviceArg.statusBase : deviceArg.telemetryBase).length);
+        const state = this.state(deviceArg);
+        if (!status && suffix === 'LWT') {
+            if (messageArg.payload === 'Offline')
+                this.markOffline(deviceArg);
+            else if (messageArg.payload === 'Online' && !this.ready(deviceArg) && !state.queryPending && !this.initializing)
+                this.refreshInBackground([deviceArg]);
+            return;
+        }
+        if (messageArg.retain && state.ready)
+            return;
+        let record = parseTasmotaRecord(messageArg.payload);
+        if (status && /^POWER(?:[1-9]\d*)?$/u.test(suffix) && typeof messageArg.payload === 'string')
+            record = { [suffix]: messageArg.payload };
+        if (!record) {
+            if (['RESULT', 'STATE', 'SENSOR', 'STATUS10', 'STATUS11'].includes(suffix))
+                this.emit({ type: 'error', deviceId: deviceArg.id, data: { message: 'Invalid Tasmota JSON state message.' } });
+            return;
+        }
+        const sensorRecord = suffix === 'STATUS10' ? tasmotaRecord(record.StatusSNS) : suffix === 'SENSOR' ? record : undefined;
+        if (sensorRecord) {
+            state.sensors = TasmotaMapper.sensors(sensorRecord);
+            state.updatedAt = new Date().toISOString();
+        }
+        else if (['RESULT', 'STATE', 'STATUS11'].includes(suffix) || /^POWER(?:[1-9]\d*)?$/u.test(suffix)) {
+            const controlRecord = suffix === 'STATUS11' ? tasmotaRecord(record.StatusSTS) : record;
+            if (!controlRecord)
+                return;
+            const controls = TasmotaMapper.controls(deviceArg, controlRecord);
+            state.updatedAt = new Date().toISOString();
+            const fullState = suffix === 'STATE' || suffix === 'STATUS11' || (suffix === 'RESULT' && (typeof controlRecord.Time === 'string' || typeof controlRecord.Uptime === 'string' || typeof controlRecord.UptimeSec === 'number'));
+            const invalidRelay = deviceArg.relays.some((relayArg) => (controlRecord[`POWER${relayArg}`] !== undefined || (relayArg === 1 && controlRecord.POWER !== undefined)) && controls[`power_${relayArg}`] === undefined);
+            const invalidDimmer = deviceArg.brightness && controlRecord.Dimmer !== undefined && controls.brightness === undefined;
+            if ((fullState && !TasmotaMapper.completeControls(deviceArg, controls)) || invalidRelay || invalidDimmer) {
+                state.controls = controls;
+                this.markOffline(deviceArg);
+                this.emit({ type: 'error', deviceId: deviceArg.id, data: { message: 'Tasmota state does not report valid configured controls.' } });
+                this.emit({ type: 'state_changed', deviceId: deviceArg.id });
+                return;
+            }
+            if (fullState)
+                state.controls = controls;
+            else
+                Object.assign(state.controls, controls);
+            if (fullState && !messageArg.retain && state.queryPending && TasmotaMapper.completeControls(deviceArg, controls)) {
+                state.ready = true;
+                state.online = true;
+                state.queryPending = false;
+                this.emit({ type: 'availability_changed', deviceId: deviceArg.id, data: { online: true } });
+            }
+        }
+        else
+            return;
+        this.emit({ type: 'state_changed', deviceId: deviceArg.id });
+        for (const handler of this.changed)
+            handler();
+    }
+    emit(eventArg) {
+        if (this.destroyed)
+            return;
+        const event = { ...eventArg, integrationDomain: this.domain, timestamp: Date.now() };
+        for (const handler of this.listeners)
+            handler(event);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tasmota.classes.runtime.js","sourceRoot":"","sources":["../../../ts/integrations/tasmota/tasmota.classes.runtime.ts"],"names":[],"mappings":"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"}

package/dist_ts/integrations/tasmota/tasmota.config.d.ts

@@ -0,0 +1,2 @@
+import type { IHomeAssistantTasmotaConfig, ITasmotaConfig } from './tasmota.types.js';
+export declare const normalizeTasmotaConfig: (configArg: IHomeAssistantTasmotaConfig) => ITasmotaConfig;

package/dist_ts/integrations/tasmota/tasmota.config.js

@@ -0,0 +1,78 @@
+import { IntegrationError } from '../../core/errors.js';
+const fail = (messageArg) => {
+    throw new IntegrationError(messageArg, 'INVALID_TASMOTA_CONFIG');
+};
+const topicPart = (valueArg, labelArg) => {
+    if (typeof valueArg !== 'string' || !valueArg.trim() || /[+#\u0000-\u001f\u007f]/u.test(valueArg) || valueArg !== valueArg.trim()) {
+        return fail(`${labelArg} must be a nonempty MQTT topic without wildcards or control characters.`);
+    }
+    return valueArg;
+};
+const selectedDevice = (deviceArg) => {
+    if (!deviceArg || typeof deviceArg !== 'object')
+        return fail('Every Tasmota device must be a config object.');
+    const topic = topicPart(deviceArg.topic, 'Tasmota topic');
+    const fullTopic = deviceArg.fullTopic ?? '%prefix%/%topic%/';
+    if (typeof fullTopic !== 'string' || fullTopic.length > 100 || !fullTopic.endsWith('/') || fullTopic.split('%prefix%').length !== 2 || fullTopic.split('%topic%').length !== 2 || /%/u.test(fullTopic.replace('%prefix%', '').replace('%topic%', ''))) {
+        return fail('FullTopic must end in / and contain exactly one %prefix% and one %topic%; other tokens are unsupported.');
+    }
+    const prefixes = deviceArg.prefixes ?? { command: 'cmnd', status: 'stat', telemetry: 'tele' };
+    if (!prefixes || typeof prefixes !== 'object')
+        return fail('Tasmota prefixes must specify command, status and telemetry strings.');
+    if (deviceArg.name !== undefined && (typeof deviceArg.name !== 'string' || !deviceArg.name.trim()))
+        return fail('Tasmota name must be a nonempty string.');
+    if (deviceArg.model !== undefined && typeof deviceArg.model !== 'string')
+        return fail('Tasmota model must be a string.');
+    const base = (prefixArg) => {
+        const prefix = topicPart(prefixArg, 'Tasmota prefix');
+        return topicPart(fullTopic.replace(/%prefix%|%topic%/gu, (tokenArg) => tokenArg === '%prefix%' ? prefix : topic), 'Tasmota FullTopic');
+    };
+    const relays = deviceArg.relays ?? [1];
+    if (!Array.isArray(relays) || relays.some((relayArg) => !Number.isInteger(relayArg) || relayArg < 1 || relayArg > 32) || new Set(relays).size !== relays.length) {
+        return fail('Tasmota relays must be unique integers from 1 through 32.');
+    }
+    if (deviceArg.brightness !== undefined && typeof deviceArg.brightness !== 'boolean')
+        return fail('Tasmota brightness must be boolean.');
+    const powerOnPayload = deviceArg.powerOnPayload ?? 'ON';
+    const powerOffPayload = deviceArg.powerOffPayload ?? 'OFF';
+    if (typeof powerOnPayload !== 'string' || !powerOnPayload || typeof powerOffPayload !== 'string' || !powerOffPayload || powerOnPayload === powerOffPayload)
+        return fail('Tasmota power state texts must be distinct nonempty strings.');
+    return {
+        id: deviceArg.id === undefined ? `tasmota:${encodeURIComponent(topic)}` : topicPart(deviceArg.id, 'Tasmota device id'),
+        topic,
+        name: deviceArg.name ?? topic,
+        model: deviceArg.model,
+        commandBase: base(prefixes.command),
+        statusBase: base(prefixes.status),
+        telemetryBase: base(prefixes.telemetry),
+        relays: [...relays].sort((leftArg, rightArg) => leftArg - rightArg),
+        brightness: deviceArg.brightness ?? false,
+        powerOnPayload,
+        powerOffPayload,
+    };
+};
+export const normalizeTasmotaConfig = (configArg) => {
+    if (!configArg || typeof configArg !== 'object' || !configArg.broker || typeof configArg.broker.host !== 'string' || !configArg.broker.host.trim() || configArg.broker.host !== configArg.broker.host.trim())
+        return fail('Tasmota requires a real MQTT broker host without surrounding whitespace.');
+    if (configArg.broker.port !== undefined && (!Number.isInteger(configArg.broker.port) || configArg.broker.port < 1 || configArg.broker.port > 65_535))
+        return fail('Tasmota broker port must be an integer from 1 through 65535.');
+    if (configArg.broker.protocol !== undefined && configArg.broker.protocol !== 'mqtt' && configArg.broker.protocol !== 'mqtts')
+        return fail('Tasmota broker protocol must be mqtt or mqtts.');
+    if (!Array.isArray(configArg.devices) || !configArg.devices.length || configArg.devices.length > 128)
+        return fail('Select from 1 through 128 Tasmota devices.');
+    const devices = configArg.devices.map(selectedDevice);
+    if (new Set(devices.map((deviceArg) => deviceArg.id)).size !== devices.length)
+        return fail('Selected Tasmota device ids must be unique.');
+    const bases = devices.flatMap((deviceArg) => [deviceArg.commandBase, deviceArg.statusBase, deviceArg.telemetryBase]);
+    if (bases.some((baseArg, indexArg) => bases.some((otherArg, otherIndexArg) => indexArg !== otherIndexArg && baseArg.startsWith(otherArg))))
+        return fail('Selected Tasmota FullTopics and prefixes must not overlap.');
+    const initialSnapshotTimeoutMs = configArg.initialSnapshotTimeoutMs ?? 10_000;
+    if (!Number.isInteger(initialSnapshotTimeoutMs) || initialSnapshotTimeoutMs < 1 || initialSnapshotTimeoutMs > 2_147_483_647)
+        return fail('initialSnapshotTimeoutMs must be a timer-safe positive integer.');
+    return {
+        devices,
+        initialSnapshotTimeoutMs,
+        broker: { ...configArg.broker, discovery: false, birthMessage: false, willMessage: false, subscriptions: [], entities: [], discoveryMessages: [], retainedMessages: [] },
+    };
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/integrations/tasmota/tasmota.discovery.d.ts

@@ -0,0 +1,7 @@
+import { DiscoveryDescriptor } from '../../core/classes.discoverydescriptor.js';
+import type { IConfigFlow, IConfigFlowContext, IConfigFlowStep, IDiscoveryCandidate } from '../../core/types.js';
+import type { IHomeAssistantTasmotaConfig } from './tasmota.types.js';
+export declare const createTasmotaDiscoveryDescriptor: () => DiscoveryDescriptor;
+export declare class TasmotaConfigFlow implements IConfigFlow<IHomeAssistantTasmotaConfig> {
+    start(candidateArg: IDiscoveryCandidate, contextArg: IConfigFlowContext): Promise<IConfigFlowStep<IHomeAssistantTasmotaConfig>>;
+}

package/dist_ts/integrations/tasmota/tasmota.discovery.js

@@ -0,0 +1,85 @@
+import { DiscoveryDescriptor } from '../../core/classes.discoverydescriptor.js';
+import { normalizeTasmotaConfig } from './tasmota.config.js';
+class TasmotaManualMatcher {
+    id = 'tasmota-selected-device';
+    source = 'manual';
+    async matches(candidateArg) {
+        const topic = candidateArg.metadata?.topic;
+        const matched = candidateArg.integrationDomain === 'tasmota' && typeof candidateArg.host === 'string' && Boolean(candidateArg.host) && typeof topic === 'string' && Boolean(topic);
+        return {
+            matched,
+            confidence: matched ? 'high' : 'low',
+            reason: matched ? 'Selected Tasmota device has a broker host and device topic; setup verifies live state.' : 'Tasmota requires an explicit broker host and device topic.',
+            candidate: matched ? candidateArg : undefined,
+            normalizedDeviceId: matched ? `tasmota:${encodeURIComponent(topic)}` : undefined,
+        };
+    }
+}
+class TasmotaCandidateValidator {
+    id = 'tasmota-selected-device-validator';
+    async validate(candidateArg) {
+        return new TasmotaManualMatcher().matches(candidateArg);
+    }
+}
+export const createTasmotaDiscoveryDescriptor = () => {
+    return new DiscoveryDescriptor({ integrationDomain: 'tasmota', displayName: 'Tasmota' })
+        .addMatcher(new TasmotaManualMatcher())
+        .addValidator(new TasmotaCandidateValidator());
+};
+export class TasmotaConfigFlow {
+    async start(candidateArg, contextArg) {
+        void contextArg;
+        return {
+            kind: 'form',
+            title: 'Connect a selected Tasmota device',
+            description: 'Use the device MQTT broker, unique Topic and FullTopic. The device must already be configured for this broker.',
+            fields: [
+                { name: 'host', label: 'MQTT broker host', type: 'text', required: true },
+                { name: 'port', label: 'MQTT broker port', type: 'number' },
+                { name: 'useTls', label: 'Use MQTT TLS', type: 'boolean' },
+                { name: 'username', label: 'Broker username', type: 'text' },
+                { name: 'password', label: 'Broker password', type: 'password' },
+                { name: 'topic', label: 'Device Topic', type: 'text', required: true },
+                { name: 'fullTopic', label: 'FullTopic', type: 'text' },
+                { name: 'relayCount', label: 'Relay count (0 through 32)', type: 'number' },
+                { name: 'brightness', label: 'Single-channel Dimmer', type: 'boolean' },
+            ],
+            submit: async (valuesArg) => {
+                try {
+                    for (const field of ['username', 'password', 'fullTopic'])
+                        if (valuesArg[field] !== undefined && typeof valuesArg[field] !== 'string')
+                            throw new Error(`${field} must be a string.`);
+                    for (const field of ['useTls', 'brightness'])
+                        if (valuesArg[field] !== undefined && typeof valuesArg[field] !== 'boolean')
+                            throw new Error(`${field} must be boolean.`);
+                    const relayCount = valuesArg.relayCount ?? 1;
+                    if (typeof relayCount !== 'number' || !Number.isInteger(relayCount) || relayCount < 0 || relayCount > 32)
+                        throw new Error('relayCount must be an integer from 0 through 32.');
+                    const host = valuesArg.host ?? candidateArg.host;
+                    const topic = valuesArg.topic ?? candidateArg.metadata?.topic;
+                    if (typeof host !== 'string' || typeof topic !== 'string')
+                        throw new Error('Broker host and device topic are required.');
+                    const port = valuesArg.port ?? candidateArg.port;
+                    if (port !== undefined && (typeof port !== 'number' || !Number.isInteger(port) || port < 1 || port > 65_535))
+                        throw new Error('Broker port must be an integer from 1 through 65535.');
+                    const config = {
+                        broker: {
+                            host,
+                            port,
+                            protocol: valuesArg.useTls === true ? 'mqtts' : 'mqtt',
+                            username: typeof valuesArg.username === 'string' ? valuesArg.username : undefined,
+                            password: typeof valuesArg.password === 'string' ? valuesArg.password : undefined,
+                        },
+                        devices: [{ topic, fullTopic: typeof valuesArg.fullTopic === 'string' && valuesArg.fullTopic ? valuesArg.fullTopic : undefined, relays: Array.from({ length: relayCount }, (_, indexArg) => indexArg + 1), brightness: valuesArg.brightness === true }],
+                    };
+                    normalizeTasmotaConfig(config);
+                    return { kind: 'done', title: 'Selected Tasmota device configured', config };
+                }
+                catch (errorArg) {
+                    return { kind: 'error', error: errorArg instanceof Error ? errorArg.message : 'Invalid Tasmota configuration.' };
+                }
+            },
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFzbW90YS5kaXNjb3ZlcnkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9pbnRlZ3JhdGlvbnMvdGFzbW90YS90YXNtb3RhLmRpc2NvdmVyeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSwyQ0FBMkMsQ0FBQztBQUVoRixPQUFPLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUc3RCxNQUFNLG9CQUFvQjtJQUNSLEVBQUUsR0FBRyx5QkFBeUIsQ0FBQztJQUMvQixNQUFNLEdBQUcsUUFBaUIsQ0FBQztJQUVwQyxLQUFLLENBQUMsT0FBTyxDQUFDLFlBQWlDO1FBQ3BELE1BQU0sS0FBSyxHQUFHLFlBQVksQ0FBQyxRQUFRLEVBQUUsS0FBSyxDQUFDO1FBQzNDLE1BQU0sT0FBTyxHQUFHLFlBQVksQ0FBQyxpQkFBaUIsS0FBSyxTQUFTLElBQUksT0FBTyxZQUFZLENBQUMsSUFBSSxLQUFLLFFBQVEsSUFBSSxPQUFPLENBQUMsWUFBWSxDQUFDLElBQUksQ0FBQyxJQUFJLE9BQU8sS0FBSyxLQUFLLFFBQVEsSUFBSSxPQUFPLENBQUMsS0FBSyxDQUFDLENBQUM7UUFDbkwsT0FBTztZQUNMLE9BQU87WUFDUCxVQUFVLEVBQUUsT0FBTyxDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLEtBQUs7WUFDcEMsTUFBTSxFQUFFLE9BQU8sQ0FBQyxDQUFDLENBQUMsd0ZBQXdGLENBQUMsQ0FBQyxDQUFDLDREQUE0RDtZQUN6SyxTQUFTLEVBQUUsT0FBTyxDQUFDLENBQUMsQ0FBQyxZQUFZLENBQUMsQ0FBQyxDQUFDLFNBQVM7WUFDN0Msa0JBQWtCLEVBQUUsT0FBTyxDQUFDLENBQUMsQ0FBQyxXQUFXLGtCQUFrQixDQUFDLEtBQUssQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLFNBQVM7U0FDakYsQ0FBQztJQUNKLENBQUM7Q0FDRjtBQUVELE1BQU0seUJBQXlCO0lBQ2IsRUFBRSxHQUFHLG1DQUFtQyxDQUFDO0lBRWxELEtBQUssQ0FBQyxRQUFRLENBQUMsWUFBaUM7UUFDckQsT0FBTyxJQUFJLG9CQUFvQixFQUFFLENBQUMsT0FBTyxDQUFDLFlBQVksQ0FBQyxDQUFDO0lBQzFELENBQUM7Q0FDRjtBQUVELE1BQU0sQ0FBQyxNQUFNLGdDQUFnQyxHQUFHLEdBQXdCLEVBQUU7SUFDeEUsT0FBTyxJQUFJLG1CQUFtQixDQUFDLEVBQUUsaUJBQWlCLEVBQUUsU0FBUyxFQUFFLFdBQVcsRUFBRSxTQUFTLEVBQUUsQ0FBQztTQUNyRixVQUFVLENBQUMsSUFBSSxvQkFBb0IsRUFBRSxDQUFDO1NBQ3RDLFlBQVksQ0FBQyxJQUFJLHlCQUF5QixFQUFFLENBQUMsQ0FBQztBQUNuRCxDQUFDLENBQUM7QUFFRixNQUFNLE9BQU8saUJBQWlCO0lBQ3JCLEtBQUssQ0FBQyxLQUFLLENBQUMsWUFBaUMsRUFBRSxVQUE4QjtRQUNsRixLQUFLLFVBQVUsQ0FBQztRQUNoQixPQUFPO1lBQ0wsSUFBSSxFQUFFLE1BQU07WUFDWixLQUFLLEVBQUUsbUNBQW1DO1lBQzFDLFdBQVcsRUFBRSxnSEFBZ0g7WUFDN0gsTUFBTSxFQUFFO2dCQUNOLEVBQUUsSUFBSSxFQUFFLE1BQU0sRUFBRSxLQUFLLEVBQUUsa0JBQWtCLEVBQUUsSUFBSSxFQUFFLE1BQU0sRUFBRSxRQUFRLEVBQUUsSUFBSSxFQUFFO2dCQUN6RSxFQUFFLElBQUksRUFBRSxNQUFNLEVBQUUsS0FBSyxFQUFFLGtCQUFrQixFQUFFLElBQUksRUFBRSxRQUFRLEVBQUU7Z0JBQzNELEVBQUUsSUFBSSxFQUFFLFFBQVEsRUFBRSxLQUFLLEVBQUUsY0FBYyxFQUFFLElBQUksRUFBRSxTQUFTLEVBQUU7Z0JBQzFELEVBQUUsSUFBSSxFQUFFLFVBQVUsRUFBRSxLQUFLLEVBQUUsaUJBQWlCLEVBQUUsSUFBSSxFQUFFLE1BQU0sRUFBRTtnQkFDNUQsRUFBRSxJQUFJLEVBQUUsVUFBVSxFQUFFLEtBQUssRUFBRSxpQkFBaUIsRUFBRSxJQUFJLEVBQUUsVUFBVSxFQUFFO2dCQUNoRSxFQUFFLElBQUksRUFBRSxPQUFPLEVBQUUsS0FBSyxFQUFFLGNBQWMsRUFBRSxJQUFJLEVBQUUsTUFBTSxFQUFFLFFBQVEsRUFBRSxJQUFJLEVBQUU7Z0JBQ3RFLEVBQUUsSUFBSSxFQUFFLFdBQVcsRUFBRSxLQUFLLEVBQUUsV0FBVyxFQUFFLElBQUksRUFBRSxNQUFNLEVBQUU7Z0JBQ3ZELEVBQUUsSUFBSSxFQUFFLFlBQVksRUFBRSxLQUFLLEVBQUUsNEJBQTRCLEVBQUUsSUFBSSxFQUFFLFFBQVEsRUFBRTtnQkFDM0UsRUFBRSxJQUFJLEVBQUUsWUFBWSxFQUFFLEtBQUssRUFBRSx1QkFBdUIsRUFBRSxJQUFJLEVBQUUsU0FBUyxFQUFFO2FBQ3hFO1lBQ0QsTUFBTSxFQUFFLEtBQUssRUFBRSxTQUFTLEVBQUUsRUFBRTtnQkFDMUIsSUFBSSxDQUFDO29CQUNILEtBQUssTUFBTSxLQUFLLElBQUksQ0FBQyxVQUFVLEVBQUUsVUFBVSxFQUFFLFdBQVcsQ0FBQzt3QkFBRSxJQUFJLFNBQVMsQ0FBQyxLQUFLLENBQUMsS0FBSyxTQUFTLElBQUksT0FBTyxTQUFTLENBQUMsS0FBSyxDQUFDLEtBQUssUUFBUTs0QkFBRSxNQUFNLElBQUksS0FBSyxDQUFDLEdBQUcsS0FBSyxvQkFBb0IsQ0FBQyxDQUFDO29CQUNyTCxLQUFLLE1BQU0sS0FBSyxJQUFJLENBQUMsUUFBUSxFQUFFLFlBQVksQ0FBQzt3QkFBRSxJQUFJLFNBQVMsQ0FBQyxLQUFLLENBQUMsS0FBSyxTQUFTLElBQUksT0FBTyxTQUFTLENBQUMsS0FBSyxDQUFDLEtBQUssU0FBUzs0QkFBRSxNQUFNLElBQUksS0FBSyxDQUFDLEdBQUcsS0FBSyxtQkFBbUIsQ0FBQyxDQUFDO29CQUN4SyxNQUFNLFVBQVUsR0FBRyxTQUFTLENBQUMsVUFBVSxJQUFJLENBQUMsQ0FBQztvQkFDN0MsSUFBSSxPQUFPLFVBQVUsS0FBSyxRQUFRLElBQUksQ0FBQyxNQUFNLENBQUMsU0FBUyxDQUFDLFVBQVUsQ0FBQyxJQUFJLFVBQVUsR0FBRyxDQUFDLElBQUksVUFBVSxHQUFHLEVBQUU7d0JBQUUsTUFBTSxJQUFJLEtBQUssQ0FBQyxrREFBa0QsQ0FBQyxDQUFDO29CQUM5SyxNQUFNLElBQUksR0FBRyxTQUFTLENBQUMsSUFBSSxJQUFJLFlBQVksQ0FBQyxJQUFJLENBQUM7b0JBQ2pELE1BQU0sS0FBSyxHQUFHLFNBQVMsQ0FBQyxLQUFLLElBQUksWUFBWSxDQUFDLFFBQVEsRUFBRSxLQUFLLENBQUM7b0JBQzlELElBQUksT0FBTyxJQUFJLEtBQUssUUFBUSxJQUFJLE9BQU8sS0FBSyxLQUFLLFFBQVE7d0JBQUUsTUFBTSxJQUFJLEtBQUssQ0FBQyw0Q0FBNEMsQ0FBQyxDQUFDO29CQUN6SCxNQUFNLElBQUksR0FBRyxTQUFTLENBQUMsSUFBSSxJQUFJLFlBQVksQ0FBQyxJQUFJLENBQUM7b0JBQ2pELElBQUksSUFBSSxLQUFLLFNBQVMsSUFBSSxDQUFDLE9BQU8sSUFBSSxLQUFLLFFBQVEsSUFBSSxDQUFDLE1BQU0sQ0FBQyxTQUFTLENBQUMsSUFBSSxDQUFDLElBQUksSUFBSSxHQUFHLENBQUMsSUFBSSxJQUFJLEdBQUcsTUFBTSxDQUFDO3dCQUFFLE1BQU0sSUFBSSxLQUFLLENBQUMsc0RBQXNELENBQUMsQ0FBQztvQkFDdEwsTUFBTSxNQUFNLEdBQWdDO3dCQUMxQyxNQUFNLEVBQUU7NEJBQ04sSUFBSTs0QkFDSixJQUFJOzRCQUNKLFFBQVEsRUFBRSxTQUFTLENBQUMsTUFBTSxLQUFLLElBQUksQ0FBQyxDQUFDLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxNQUFNOzRCQUN0RCxRQUFRLEVBQUUsT0FBTyxTQUFTLENBQUMsUUFBUSxLQUFLLFFBQVEsQ0FBQyxDQUFDLENBQUMsU0FBUyxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUMsU0FBUzs0QkFDakYsUUFBUSxFQUFFLE9BQU8sU0FBUyxDQUFDLFFBQVEsS0FBSyxRQUFRLENBQUMsQ0FBQyxDQUFDLFNBQVMsQ0FBQyxRQUFRLENBQUMsQ0FBQyxDQUFDLFNBQVM7eUJBQ2xGO3dCQUNELE9BQU8sRUFBRSxDQUFDLEVBQUUsS0FBSyxFQUFFLFNBQVMsRUFBRSxPQUFPLFNBQVMsQ0FBQyxTQUFTLEtBQUssUUFBUSxJQUFJLFNBQVMsQ0FBQyxTQUFTLENBQUMsQ0FBQyxDQUFDLFNBQVMsQ0FBQyxTQUFTLENBQUMsQ0FBQyxDQUFDLFNBQVMsRUFBRSxNQUFNLEVBQUUsS0FBSyxDQUFDLElBQUksQ0FBQyxFQUFFLE1BQU0sRUFBRSxVQUFVLEVBQUUsRUFBRSxDQUFDLENBQUMsRUFBRSxRQUFRLEVBQUUsRUFBRSxDQUFDLFFBQVEsR0FBRyxDQUFDLENBQUMsRUFBRSxVQUFVLEVBQUUsU0FBUyxDQUFDLFVBQVUsS0FBSyxJQUFJLEVBQUUsQ0FBQztxQkFDeFAsQ0FBQztvQkFDRixzQkFBc0IsQ0FBQyxNQUFNLENBQUMsQ0FBQztvQkFDL0IsT0FBTyxFQUFFLElBQUksRUFBRSxNQUFNLEVBQUUsS0FBSyxFQUFFLG9DQUFvQyxFQUFFLE1BQU0sRUFBRSxDQUFDO2dCQUMvRSxDQUFDO2dCQUFDLE9BQU8sUUFBUSxFQUFFLENBQUM7b0JBQ2xCLE9BQU8sRUFBRSxJQUFJLEVBQUUsT0FBTyxFQUFFLEtBQUssRUFBRSxRQUFRLFlBQVksS0FBSyxDQUFDLENBQUMsQ0FBQyxRQUFRLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxnQ0FBZ0MsRUFBRSxDQUFDO2dCQUNuSCxDQUFDO1lBQ0gsQ0FBQztTQUNGLENBQUM7SUFDSixDQUFDO0NBQ0YifQ==

package/dist_ts/integrations/tasmota/tasmota.mapper.d.ts

@@ -0,0 +1,12 @@
+import * as plugins from '../../plugins.js';
+import type { IIntegrationEntity } from '../../core/types.js';
+import type { ITasmotaDeviceState, ITasmotaSelectedDevice } from './tasmota.types.js';
+export declare const tasmotaRecord: (valueArg: unknown) => Record<string, unknown> | undefined;
+export declare const parseTasmotaRecord: (payloadArg: unknown) => Record<string, unknown> | undefined;
+export declare class TasmotaMapper {
+    static controls(deviceArg: ITasmotaSelectedDevice, recordArg: Record<string, unknown>): Record<string, boolean | number>;
+    static completeControls(deviceArg: ITasmotaSelectedDevice, controlsArg: Record<string, boolean | number>): boolean;
+    static sensors(recordArg: Record<string, unknown>): Record<string, number | boolean | string>;
+    static device(deviceArg: ITasmotaSelectedDevice, stateArg: ITasmotaDeviceState, connectedArg: boolean): plugins.shxInterfaces.data.IDeviceDefinition;
+    static entities(deviceArg: plugins.shxInterfaces.data.IDeviceDefinition): IIntegrationEntity[];
+}