@smarthome.exchange/integrations 0.1.0 → 1.0.0

package/dist_ts/integrations/shelly/shelly.classes.client.js

@@ -1,158 +1,342 @@
 import * as plugins from '../../plugins.js';
+import { AuthenticationError, DeviceCommunicationError } from '../../core/errors.js';
+import { ShellySubscription } from './shelly.classes.subscription.js';
+import { createShellyDigest, isShellyRecord, mergeShellyStatus, parseShellyConfig, parseShellyDeviceInfo, parseShellyHttpChallenge, parseShellyRpcResult, parseShellyStatus, } from './shelly.rpc.js';
 export class ShellyClient {
-    config;
+    logger;
     requestId = 1;
     nonceCount = 0;
     digestChallenge;
-    constructor(config) {
+    deviceId;
+    snapshot;
+    subscription;
+    subscribers = new Set();
+    lifetime = new AbortController();
+    lifetimeSignal;
+    // Firmware tracks increasing digest nonce counts, so HTTP calls must arrive in order.
+    requestQueue = Promise.resolve();
+    timeoutMs;
+    endpoint;
+    config;
+    healthy = false;
+    destroyed = false;
+    constructor(configArg, abortSignalArg, logger) {
+        this.logger = logger;
+        const config = {
+            host: configArg.host,
+            port: configArg.port,
+            protocol: configArg.protocol,
+            username: configArg.username,
+            password: configArg.password,
+            requestTimeoutMs: configArg.requestTimeoutMs,
+        };
         this.config = config;
-    }
-    async getSnapshot() {
-        const deviceInfo = await this.getDeviceInfo();
-        const status = await this.getStatus();
-        const deviceConfig = await this.getDeviceConfig();
-        return { deviceInfo, status, deviceConfig };
-    }
-    async getDeviceInfo() {
-        if (this.config.deviceInfo) {
-            return this.config.deviceInfo;
-        }
-        return this.requestJson('/shelly');
-    }
-    async getStatus() {
-        if (this.config.status) {
-            return this.config.status;
+        this.timeoutMs = config.requestTimeoutMs ?? 10000;
+        if (!Number.isSafeInteger(this.timeoutMs) || this.timeoutMs < 10 || this.timeoutMs > 60000) {
+            throw new Error('Shelly requestTimeoutMs must be an integer between 10 and 60000.');
         }
-        return this.callRpc('Shelly.GetStatus');
-    }
-    async getDeviceConfig() {
-        if (this.config.deviceConfig) {
-            return this.config.deviceConfig;
+        if (config.username !== undefined && config.username !== 'admin')
+            throw new AuthenticationError('Shelly authentication username must be admin.');
+        if (config.password !== undefined && typeof config.password !== 'string')
+            throw new AuthenticationError('Shelly password must be a string.');
+        if (config.protocol !== undefined && config.protocol !== 'http' && config.protocol !== 'https')
+            throw new Error('Shelly protocol must be http or https.');
+        if (config.port !== undefined && (!Number.isSafeInteger(config.port) || config.port < 1 || config.port > 65535))
+            throw new Error('Shelly port must be between 1 and 65535.');
+        if (config.host === undefined)
+            throw new Error('Shelly host is required for live requests.');
+        if (typeof config.host !== 'string' || !config.host || /[\s\/?#@]/.test(config.host))
+            throw new Error('Shelly host must be a hostname or IP address.');
+        const host = config.host.includes(':') && !config.host.startsWith('[') ? `[${config.host}]` : config.host;
+        try {
+            this.endpoint = new URL(`${config.protocol ?? 'http'}://${host}${config.port === undefined ? '' : `:${config.port}`}`);
         }
-        if (!this.config.host) {
-            return undefined;
+        catch {
+            throw new Error('Shelly host must be a hostname or IP address.');
         }
-        return this.callRpc('Shelly.GetConfig');
+        this.lifetimeSignal = AbortSignal.any([this.lifetime.signal, ...(abortSignalArg ? [abortSignalArg] : [])]);
     }
-    async setSwitchOutput(switchIdArg, onArg) {
-        await this.callRpc('Switch.Set', {
-            id: switchIdArg,
-            on: onArg,
+    isHealthy() {
+        return !this.destroyed && !this.lifetimeSignal.aborted && this.healthy && (!this.subscription || this.subscription.isHealthy);
+    }
+    async getSnapshot(abortSignalArg) {
+        this.assertActive(abortSignalArg);
+        if (this.snapshot && this.subscription?.isHealthy)
+            return structuredClone(this.snapshot);
+        const deviceInfo = await this.getDeviceInfo(abortSignalArg);
+        const status = await this.getStatus(abortSignalArg);
+        const deviceConfig = await this.getDeviceConfig(abortSignalArg);
+        this.snapshot = { deviceInfo, status, deviceConfig };
+        return structuredClone(this.snapshot);
+    }
+    async getDeviceInfo(abortSignalArg) {
+        this.assertActive(abortSignalArg);
+        const response = await this.requestJson('/shelly', undefined, abortSignalArg);
+        const deviceInfo = this.parseResponse(() => {
+            const info = parseShellyDeviceInfo(response);
+            if (this.deviceId !== undefined && this.deviceId !== info.id)
+                throw new DeviceCommunicationError('Shelly endpoint device identity changed.');
+            return info;
         });
+        this.deviceId = deviceInfo.id;
+        return deviceInfo;
+    }
+    async getStatus(abortSignalArg) {
+        this.assertActive(abortSignalArg);
+        const response = await this.callRpc('Shelly.GetStatus', undefined, abortSignalArg);
+        const status = this.parseResponse(() => parseShellyStatus(response));
+        this.healthy = true;
+        if (this.snapshot)
+            this.updateStatus(status, true, Date.now());
+        return status;
+    }
+    async getDeviceConfig(abortSignalArg) {
+        this.assertActive(abortSignalArg);
+        const response = await this.callRpc('Shelly.GetConfig', undefined, abortSignalArg);
+        return this.parseResponse(() => parseShellyConfig(response));
     }
-    async destroy() { }
-    async callRpc(methodArg, paramsArg) {
-        const response = await this.requestJson('/rpc', {
-            id: this.requestId++,
-            method: methodArg,
-            params: paramsArg,
+    async setSwitchOutput(switchIdArg, onArg, abortSignalArg) {
+        if (!Number.isSafeInteger(switchIdArg) || switchIdArg < 0 || typeof onArg !== 'boolean')
+            throw new Error('Shelly switch writes require a non-negative integer id and boolean output.');
+        const snapshot = await this.getSnapshot(abortSignalArg);
+        if (!isShellyRecord(snapshot.status[`switch:${switchIdArg}`]))
+            throw new Error('Shelly switch is not present on the connected device.');
+        const result = await this.callRpc('Switch.Set', { id: switchIdArg, on: onArg }, abortSignalArg);
+        this.parseResponse(() => {
+            if (typeof result.was_on !== 'boolean')
+                throw new DeviceCommunicationError('Shelly returned an invalid switch response.');
         });
-        if (this.isRecord(response) && 'error' in response) {
-            const error = response.error;
-            throw new Error(`Shelly RPC ${methodArg} failed: ${JSON.stringify(error)}`);
+        await this.getStatus(abortSignalArg);
+    }
+    async subscribe(handlerArg, abortSignalArg) {
+        this.assertActive(abortSignalArg);
+        if (!this.snapshot)
+            await this.getSnapshot(abortSignalArg);
+        let rejectCancelled;
+        const cancellation = new Promise((_, rejectArg) => { rejectCancelled = rejectArg; });
+        const subscriber = {
+            handler: handlerArg,
+            signal: abortSignalArg,
+            abort: () => {
+                rejectCancelled?.(new DOMException('Shelly subscription cancelled.', 'AbortError'));
+                void unsubscribe().catch(() => {
+                    this.logger?.log('error', 'Shelly subscription cleanup failed.');
+                    this.emit({ type: 'error', error: new DeviceCommunicationError('Shelly subscription cleanup failed.'), timestamp: Date.now() });
+                });
+            },
+        };
+        let removed = false;
+        const unsubscribe = async () => {
+            if (!removed) {
+                removed = true;
+                subscriber.signal?.removeEventListener('abort', subscriber.abort);
+                this.subscribers.delete(subscriber);
+            }
+            if (this.subscribers.size === 0 && this.subscription) {
+                const subscription = this.subscription;
+                await subscription.stop();
+                if (this.subscription === subscription)
+                    this.subscription = undefined;
+            }
+        };
+        this.subscribers.add(subscriber);
+        abortSignalArg?.addEventListener('abort', subscriber.abort, { once: true });
+        if (abortSignalArg?.aborted)
+            subscriber.abort();
+        try {
+            await Promise.race([this.connectSubscription(), cancellation]);
+            this.assertActive(abortSignalArg);
+            rejectCancelled = undefined;
+            return unsubscribe;
         }
-        if (this.isRecord(response) && 'result' in response) {
-            return response.result;
+        catch (errorArg) {
+            await unsubscribe();
+            throw errorArg;
         }
-        if (this.isRecord(response) && 'params' in response) {
-            return response.params;
+    }
+    async destroy() {
+        this.destroyed = true;
+        this.healthy = false;
+        for (const subscriber of this.subscribers)
+            subscriber.signal?.removeEventListener('abort', subscriber.abort);
+        this.subscribers.clear();
+        this.lifetime.abort();
+        await this.requestQueue;
+        if (this.subscription) {
+            await this.subscription.stop();
+            this.subscription = undefined;
         }
-        return response;
     }
-    async requestJson(pathArg, bodyArg) {
-        if (!this.config.host) {
-            throw new Error('Shelly host is required when fixture data is not provided.');
+    async connectSubscription() {
+        if (this.subscription?.isStopping) {
+            const previous = this.subscription;
+            await previous.stop();
+            if (this.subscription === previous)
+                this.subscription = undefined;
         }
-        const method = bodyArg ? 'POST' : 'GET';
-        const firstResponse = await this.fetchPath(pathArg, method, bodyArg);
-        if (firstResponse.status !== 401) {
-            return this.parseJsonResponse(firstResponse, pathArg);
+        this.assertActive();
+        if (!this.subscription || this.subscription.isClosed) {
+            if (!this.deviceId)
+                throw new Error('Shelly subscription requires a validated device.');
+            const url = new URL('/rpc', this.endpoint);
+            url.protocol = this.endpoint.protocol === 'https:' ? 'wss:' : 'ws:';
+            this.subscription = new ShellySubscription({
+                url: url.toString(),
+                deviceId: this.deviceId,
+                source: `shx-${plugins.crypto.randomUUID()}`,
+                password: this.config.password,
+                timeoutMs: this.timeoutMs,
+                abortSignal: this.lifetimeSignal,
+                onStatus: (statusArg, fullArg, timestampArg) => this.updateStatus(statusArg, fullArg, timestampArg),
+                onEvent: (eventArg, timestampArg) => {
+                    this.emit({ type: 'event', event: eventArg, timestamp: timestampArg });
+                    if (eventArg.event === 'config_changed')
+                        void this.refreshConfig(timestampArg);
+                },
+                onAvailability: (availableArg) => this.emit({ type: 'availability', available: availableArg, timestamp: Date.now() }),
+                onError: (errorArg) => this.emit({ type: 'error', error: errorArg, timestamp: Date.now() }),
+            });
         }
-        if (!this.config.password) {
-            throw new Error('Shelly device requires authentication, but no password was provided.');
+        await this.subscription.start();
+    }
+    updateStatus(statusArg, fullArg, timestampArg) {
+        if (!this.snapshot || this.destroyed)
+            return;
+        this.snapshot = { ...this.snapshot, status: fullArg ? statusArg : mergeShellyStatus(this.snapshot.status, statusArg) };
+        this.emit({ type: 'status', snapshot: structuredClone(this.snapshot), timestamp: timestampArg });
+    }
+    emit(eventArg) {
+        for (const subscriber of [...this.subscribers]) {
+            if (!this.subscribers.has(subscriber))
+                continue;
+            try {
+                subscriber.handler(structuredClone(eventArg));
+            }
+            catch {
+                this.logger?.log('error', 'Shelly subscriber callback failed.');
+                subscriber.abort();
+                this.emit({ type: 'error', error: new DeviceCommunicationError('Shelly subscriber callback failed.'), timestamp: Date.now() });
+            }
         }
-        this.digestChallenge = this.parseDigestChallenge(firstResponse.headers.get('www-authenticate'));
-        this.nonceCount = 0;
-        const secondResponse = await this.fetchPath(pathArg, method, bodyArg);
-        return this.parseJsonResponse(secondResponse, pathArg);
     }
-    async fetchPath(pathArg, methodArg, bodyArg) {
-        const headers = {};
-        if (bodyArg) {
-            headers['content-type'] = 'application/json';
+    async refreshConfig(timestampArg) {
+        try {
+            const deviceConfig = await this.getDeviceConfig();
+            if (this.snapshot && !this.destroyed) {
+                this.snapshot = { ...this.snapshot, deviceConfig };
+                this.emit({ type: 'status', snapshot: structuredClone(this.snapshot), timestamp: timestampArg });
+            }
         }
-        if (this.digestChallenge) {
-            headers.authorization = this.createDigestAuthorization(methodArg, pathArg);
+        catch {
+            if (!this.destroyed && !this.lifetimeSignal.aborted)
+                this.emit({ type: 'error', error: new DeviceCommunicationError('Shelly configuration refresh failed.'), timestamp: Date.now() });
         }
-        return globalThis.fetch(`${this.baseUrl()}${pathArg}`, {
-            method: methodArg,
-            headers,
-            body: bodyArg ? JSON.stringify(bodyArg) : undefined,
-        });
     }
-    async parseJsonResponse(responseArg, pathArg) {
-        if (!responseArg.ok) {
-            const text = await responseArg.text();
-            throw new Error(`Shelly request ${pathArg} failed with HTTP ${responseArg.status}: ${text}`);
+    parseResponse(parserArg) {
+        try {
+            return parserArg();
+        }
+        catch (errorArg) {
+            this.healthy = false;
+            throw errorArg;
         }
-        return responseArg.json();
     }
-    parseDigestChallenge(headerArg) {
-        if (!headerArg) {
-            throw new Error('Shelly authentication challenge did not include a WWW-Authenticate header.');
+    async callRpc(methodArg, paramsArg, abortSignalArg) {
+        if (!this.deviceId)
+            await this.getDeviceInfo(abortSignalArg);
+        const id = this.requestId++;
+        const source = 'smarthome.exchange';
+        const frame = await this.requestJson('/rpc', { id, src: source, method: methodArg, params: paramsArg }, abortSignalArg);
+        return this.parseResponse(() => parseShellyRpcResult(frame, id, this.deviceId, source));
+    }
+    async requestJson(pathArg, bodyArg, abortSignalArg) {
+        this.assertActive(abortSignalArg);
+        const deadline = new AbortController();
+        let timedOut = false;
+        const timer = setTimeout(() => { timedOut = true; deadline.abort(); }, this.timeoutMs);
+        const signal = AbortSignal.any([deadline.signal, this.lifetimeSignal, ...(abortSignalArg ? [abortSignalArg] : [])]);
+        const cancelled = () => timedOut ? new DeviceCommunicationError('Shelly request timed out.') : new DOMException('Shelly request cancelled.', 'AbortError');
+        let rejectCancelled;
+        const cancellation = new Promise((_, rejectArg) => { rejectCancelled = rejectArg; });
+        const handleAbort = () => rejectCancelled?.(cancelled());
+        signal.addEventListener('abort', handleAbort, { once: true });
+        if (signal.aborted)
+            handleAbort();
+        const operation = this.requestQueue.then(async () => {
+            if (signal.aborted)
+                throw cancelled();
+            const method = bodyArg ? 'POST' : 'GET';
+            let response = await this.fetchPath(pathArg, method, bodyArg, signal);
+            if (response.status === 401) {
+                await response.body?.cancel();
+                if (!this.config.password)
+                    throw new AuthenticationError('Shelly authentication requires a password.');
+                this.digestChallenge = parseShellyHttpChallenge(response.headers.get('www-authenticate'), this.deviceId);
+                this.nonceCount = 0;
+                response = await this.fetchPath(pathArg, method, bodyArg, signal);
+            }
+            if (!response.ok) {
+                await response.body?.cancel();
+                if (response.status === 401)
+                    throw new AuthenticationError('Shelly authentication failed.');
+                throw new DeviceCommunicationError(`Shelly request failed with HTTP ${response.status}.`);
+            }
+            if (!response.body)
+                throw new DeviceCommunicationError('Shelly returned an empty response.');
+            const reader = response.body.getReader();
+            const chunks = [];
+            let size = 0;
+            try {
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    size += value.byteLength;
+                    if (size > 1024 * 1024) {
+                        await reader.cancel();
+                        throw new DeviceCommunicationError('Shelly response exceeds the size limit.');
+                    }
+                    chunks.push(value);
+                }
+            }
+            finally {
+                reader.releaseLock();
+            }
+            return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+        });
+        this.requestQueue = operation.then(() => undefined, () => undefined);
+        try {
+            return await Promise.race([operation, cancellation]);
         }
-        const values = {};
-        const regex = /(\w+)=(?:"([^"]*)"|([^,\s]+))/g;
-        let match;
-        while ((match = regex.exec(headerArg))) {
-            values[match[1]] = match[2] ?? match[3] ?? '';
+        catch (errorArg) {
+            this.healthy = false;
+            if (signal.aborted)
+                throw cancelled();
+            if (errorArg instanceof AuthenticationError || errorArg instanceof DeviceCommunicationError)
+                throw errorArg;
+            throw new DeviceCommunicationError('Shelly request failed or returned invalid JSON.');
         }
-        if (!values.realm || !values.nonce) {
-            throw new Error(`Unsupported Shelly authentication challenge: ${headerArg}`);
+        finally {
+            clearTimeout(timer);
+            signal.removeEventListener('abort', handleAbort);
+            rejectCancelled = undefined;
         }
-        return {
-            realm: values.realm,
-            nonce: values.nonce,
-            qop: values.qop,
-            opaque: values.opaque,
-        };
     }
-    createDigestAuthorization(methodArg, pathArg) {
-        if (!this.digestChallenge || !this.config.password) {
-            throw new Error('Shelly digest authentication cannot be created before a challenge is received.');
-        }
-        const username = this.config.username || 'admin';
-        const cnonce = plugins.crypto.randomBytes(8).toString('hex');
-        const nc = (++this.nonceCount).toString(16).padStart(8, '0');
-        const ha1 = this.sha256(`${username}:${this.digestChallenge.realm}:${this.config.password}`);
-        const ha2 = this.sha256(`${methodArg}:${pathArg}`);
-        const response = this.sha256(`${ha1}:${this.digestChallenge.nonce}:${nc}:${cnonce}:auth:${ha2}`);
-        const parts = [
-            `username="${username}"`,
-            `realm="${this.digestChallenge.realm}"`,
-            `nonce="${this.digestChallenge.nonce}"`,
-            `uri="${pathArg}"`,
-            'algorithm=SHA-256',
-            `response="${response}"`,
-            'qop=auth',
-            `nc=${nc}`,
-            `cnonce="${cnonce}"`,
-        ];
-        if (this.digestChallenge.opaque) {
-            parts.push(`opaque="${this.digestChallenge.opaque}"`);
-        }
-        return `Digest ${parts.join(', ')}`;
-    }
-    sha256(valueArg) {
-        return plugins.crypto.createHash('sha256').update(valueArg).digest('hex');
-    }
-    baseUrl() {
-        const protocol = this.config.protocol || 'http';
-        const port = this.config.port && this.config.port !== 80 ? `:${this.config.port}` : '';
-        return `${protocol}://${this.config.host}${port}`;
-    }
-    isRecord(valueArg) {
-        return typeof valueArg === 'object' && valueArg !== null && !Array.isArray(valueArg);
+    async fetchPath(pathArg, methodArg, bodyArg, signalArg) {
+        const headers = {};
+        if (bodyArg)
+            headers['content-type'] = 'application/json';
+        if (this.digestChallenge && this.config.password) {
+            const digest = createShellyDigest(this.digestChallenge, this.config.password, ++this.nonceCount, methodArg, pathArg);
+            headers.authorization = `Digest username="admin", realm="${this.digestChallenge.realm}", nonce="${this.digestChallenge.nonce}", uri="${pathArg}", algorithm=SHA-256, response="${digest.response}", qop=auth, nc=${digest.nc}, cnonce="${digest.cnonce}"${this.digestChallenge.opaque ? `, opaque="${this.digestChallenge.opaque}"` : ''}`;
+        }
+        return globalThis.fetch(new URL(pathArg, this.endpoint), { method: methodArg, headers, body: bodyArg ? JSON.stringify(bodyArg) : undefined, signal: signalArg, redirect: 'error' });
+    }
+    assertActive(abortSignalArg) {
+        if (this.destroyed)
+            throw new Error('Shelly client has been destroyed.');
+        if (this.lifetimeSignal.aborted || abortSignalArg?.aborted)
+            throw new DOMException('Shelly operation cancelled.', 'AbortError');
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"shelly.classes.client.js","sourceRoot":"","sources":["../../../ts/integrations/shelly/shelly.classes.client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,kBAAkB,CAAC;AAU5C,MAAM,OAAO,YAAY;IAKM;IAJrB,SAAS,GAAG,CAAC,CAAC;IACd,UAAU,GAAG,CAAC,CAAC;IACf,eAAe,CAA0B;IAEjD,YAA6B,MAAqB;QAArB,WAAM,GAAN,MAAM,CAAe;IAAG,CAAC;IAE/C,KAAK,CAAC,WAAW;QACtB,MAAM,UAAU,GAAG,MAAM,IAAI,CAAC,aAAa,EAAE,CAAC;QAC9C,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,SAAS,EAAE,CAAC;QACtC,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,eAAe,EAAE,CAAC;QAClD,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,YAAY,EAAE,CAAC;IAC9C,CAAC;IAEM,KAAK,CAAC,aAAa;QACxB,IAAI,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC;YAC3B,OAAO,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC;QAChC,CAAC;QACD,OAAO,IAAI,CAAC,WAAW,CAAoB,SAAS,CAAC,CAAC;IACxD,CAAC;IAEM,KAAK,CAAC,SAAS;QACpB,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC;YACvB,OAAO,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC;QAC5B,CAAC;QACD,OAAO,IAAI,CAAC,OAAO,CAAgB,kBAAkB,CAAC,CAAC;IACzD,CAAC;IAEM,KAAK,CAAC,eAAe;QAC1B,IAAI,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE,CAAC;YAC7B,OAAO,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC;QAClC,CAAC;QACD,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;YACtB,OAAO,SAAS,CAAC;QACnB,CAAC;QACD,OAAO,IAAI,CAAC,OAAO,CAAsB,kBAAkB,CAAC,CAAC;IAC/D,CAAC;IAEM,KAAK,CAAC,eAAe,CAAC,WAAmB,EAAE,KAAc;QAC9D,MAAM,IAAI,CAAC,OAAO,CAAC,YAAY,EAAE;YAC/B,EAAE,EAAE,WAAW;YACf,EAAE,EAAE,KAAK;SACV,CAAC,CAAC;IACL,CAAC;IAEM,KAAK,CAAC,OAAO,KAAmB,CAAC;IAEhC,KAAK,CAAC,OAAO,CAAU,SAAiB,EAAE,SAAmC;QACnF,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,WAAW,CAAU,MAAM,EAAE;YACvD,EAAE,EAAE,IAAI,CAAC,SAAS,EAAE;YACpB,MAAM,EAAE,SAAS;YACjB,MAAM,EAAE,SAAS;SAClB,CAAC,CAAC;QACH,IAAI,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,OAAO,IAAI,QAAQ,EAAE,CAAC;YACnD,MAAM,KAAK,GAAG,QAAQ,CAAC,KAAK,CAAC;YAC7B,MAAM,IAAI,KAAK,CAAC,cAAc,SAAS,YAAY,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;QAC9E,CAAC;QACD,IAAI,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,QAAQ,IAAI,QAAQ,EAAE,CAAC;YACpD,OAAO,QAAQ,CAAC,MAAiB,CAAC;QACpC,CAAC;QACD,IAAI,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,QAAQ,IAAI,QAAQ,EAAE,CAAC;YACpD,OAAO,QAAQ,CAAC,MAAiB,CAAC;QACpC,CAAC;QACD,OAAO,QAAmB,CAAC;IAC7B,CAAC;IAEO,KAAK,CAAC,WAAW,CAAU,OAAe,EAAE,OAAiC;QACnF,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;YACtB,MAAM,IAAI,KAAK,CAAC,4DAA4D,CAAC,CAAC;QAChF,CAAC;QAED,MAAM,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC;QACxC,MAAM,aAAa,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;QACrE,IAAI,aAAa,CAAC,MAAM,KAAK,GAAG,EAAE,CAAC;YACjC,OAAO,IAAI,CAAC,iBAAiB,CAAU,aAAa,EAAE,OAAO,CAAC,CAAC;QACjE,CAAC;QAED,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC;YAC1B,MAAM,IAAI,KAAK,CAAC,sEAAsE,CAAC,CAAC;QAC1F,CAAC;QAED,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,oBAAoB,CAAC,aAAa,CAAC,OAAO,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC,CAAC;QAChG,IAAI,CAAC,UAAU,GAAG,CAAC,CAAC;QAEpB,MAAM,cAAc,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;QACtE,OAAO,IAAI,CAAC,iBAAiB,CAAU,cAAc,EAAE,OAAO,CAAC,CAAC;IAClE,CAAC;IAEO,KAAK,CAAC,SAAS,CAAC,OAAe,EAAE,SAAiB,EAAE,OAAiC;QAC3F,MAAM,OAAO,GAA2B,EAAE,CAAC;QAC3C,IAAI,OAAO,EAAE,CAAC;YACZ,OAAO,CAAC,cAAc,CAAC,GAAG,kBAAkB,CAAC;QAC/C,CAAC;QACD,IAAI,IAAI,CAAC,eAAe,EAAE,CAAC;YACzB,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC,yBAAyB,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;QAC7E,CAAC;QAED,OAAO,UAAU,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,OAAO,EAAE,GAAG,OAAO,EAAE,EAAE;YACrD,MAAM,EAAE,SAAS;YACjB,OAAO;YACP,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS;SACpD,CAAC,CAAC;IACL,CAAC;IAEO,KAAK,CAAC,iBAAiB,CAAU,WAAqB,EAAE,OAAe;QAC7E,IAAI,CAAC,WAAW,CAAC,EAAE,EAAE,CAAC;YACpB,MAAM,IAAI,GAAG,MAAM,WAAW,CAAC,IAAI,EAAE,CAAC;YACtC,MAAM,IAAI,KAAK,CAAC,kBAAkB,OAAO,qBAAqB,WAAW,CAAC,MAAM,KAAK,IAAI,EAAE,CAAC,CAAC;QAC/F,CAAC;QACD,OAAO,WAAW,CAAC,IAAI,EAAsB,CAAC;IAChD,CAAC;IAEO,oBAAoB,CAAC,SAAwB;QACnD,IAAI,CAAC,SAAS,EAAE,CAAC;YACf,MAAM,IAAI,KAAK,CAAC,4EAA4E,CAAC,CAAC;QAChG,CAAC;QACD,MAAM,MAAM,GAA2B,EAAE,CAAC;QAC1C,MAAM,KAAK,GAAG,gCAAgC,CAAC;QAC/C,IAAI,KAA6B,CAAC;QAClC,OAAO,CAAC,KAAK,GAAG,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC;YACvC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;QAChD,CAAC;QACD,IAAI,CAAC,MAAM,CAAC,KAAK,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;YACnC,MAAM,IAAI,KAAK,CAAC,gDAAgD,SAAS,EAAE,CAAC,CAAC;QAC/E,CAAC;QACD,OAAO;YACL,KAAK,EAAE,MAAM,CAAC,KAAK;YACnB,KAAK,EAAE,MAAM,CAAC,KAAK;YACnB,GAAG,EAAE,MAAM,CAAC,GAAG;YACf,MAAM,EAAE,MAAM,CAAC,MAAM;SACtB,CAAC;IACJ,CAAC;IAEO,yBAAyB,CAAC,SAAiB,EAAE,OAAe;QAClE,IAAI,CAAC,IAAI,CAAC,eAAe,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC;YACnD,MAAM,IAAI,KAAK,CAAC,gFAAgF,CAAC,CAAC;QACpG,CAAC;QAED,MAAM,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,QAAQ,IAAI,OAAO,CAAC;QACjD,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;QAC7D,MAAM,EAAE,GAAG,CAAC,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;QAC7D,MAAM,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,QAAQ,IAAI,IAAI,CAAC,eAAe,CAAC,KAAK,IAAI,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC;QAC7F,MAAM,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,SAAS,IAAI,OAAO,EAAE,CAAC,CAAC;QACnD,MAAM,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,GAAG,IAAI,IAAI,CAAC,eAAe,CAAC,KAAK,IAAI,EAAE,IAAI,MAAM,SAAS,GAAG,EAAE,CAAC,CAAC;QACjG,MAAM,KAAK,GAAG;YACZ,aAAa,QAAQ,GAAG;YACxB,UAAU,IAAI,CAAC,eAAe,CAAC,KAAK,GAAG;YACvC,UAAU,IAAI,CAAC,eAAe,CAAC,KAAK,GAAG;YACvC,QAAQ,OAAO,GAAG;YAClB,mBAAmB;YACnB,aAAa,QAAQ,GAAG;YACxB,UAAU;YACV,MAAM,EAAE,EAAE;YACV,WAAW,MAAM,GAAG;SACrB,CAAC;QACF,IAAI,IAAI,CAAC,eAAe,CAAC,MAAM,EAAE,CAAC;YAChC,KAAK,CAAC,IAAI,CAAC,WAAW,IAAI,CAAC,eAAe,CAAC,MAAM,GAAG,CAAC,CAAC;QACxD,CAAC;QACD,OAAO,UAAU,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;IACtC,CAAC;IAEO,MAAM,CAAC,QAAgB;QAC7B,OAAO,OAAO,CAAC,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IAC5E,CAAC;IAEO,OAAO;QACb,MAAM,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,QAAQ,IAAI,MAAM,CAAC;QAChD,MAAM,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,IAAI,IAAI,CAAC,MAAM,CAAC,IAAI,KAAK,EAAE,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QACvF,OAAO,GAAG,QAAQ,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,GAAG,IAAI,EAAE,CAAC;IACpD,CAAC;IAEO,QAAQ,CAAC,QAAiB;QAChC,OAAO,OAAO,QAAQ,KAAK,QAAQ,IAAI,QAAQ,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;IACvF,CAAC;CACF"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"shelly.classes.client.js","sourceRoot":"","sources":["../../../ts/integrations/shelly/shelly.classes.client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,kBAAkB,CAAC;AAC5C,OAAO,EAAE,mBAAmB,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAErF,OAAO,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AACtE,OAAO,EACL,kBAAkB,EAClB,cAAc,EACd,iBAAiB,EACjB,iBAAiB,EACjB,qBAAqB,EACrB,wBAAwB,EACxB,oBAAoB,EACpB,iBAAiB,GAClB,MAAM,iBAAiB,CAAC;AAUzB,MAAM,OAAO,YAAY;IAkB8D,MAAM;IAjBnF,SAAS,GAAG,CAAC,CAAC;IACd,UAAU,GAAG,CAAC,CAAC;IACf,eAAe,CAA0B;IACzC,QAAQ,CAAU;IAClB,QAAQ,CAAmB;IAC3B,YAAY,CAAsB;IACzB,WAAW,GAAG,IAAI,GAAG,EAAqB,CAAC;IAC3C,QAAQ,GAAG,IAAI,eAAe,EAAE,CAAC;IACjC,cAAc,CAAc;IAC7C,sFAAsF;IAC9E,YAAY,GAAkB,OAAO,CAAC,OAAO,EAAE,CAAC;IACvC,SAAS,CAAS;IAClB,QAAQ,CAAM;IACd,MAAM,CAAgB;IAC/B,OAAO,GAAG,KAAK,CAAC;IAChB,SAAS,GAAG,KAAK,CAAC;IAE1B,YAAY,SAAwB,EAAE,cAA4B,EAAmB,MAAgB;sBAAhB,MAAM;QACzF,MAAM,MAAM,GAAkB;YAC5B,IAAI,EAAE,SAAS,CAAC,IAAI;YACpB,IAAI,EAAE,SAAS,CAAC,IAAI;YACpB,QAAQ,EAAE,SAAS,CAAC,QAAQ;YAC5B,QAAQ,EAAE,SAAS,CAAC,QAAQ;YAC5B,QAAQ,EAAE,SAAS,CAAC,QAAQ;YAC5B,gBAAgB,EAAE,SAAS,CAAC,gBAAgB;SAC7C,CAAC;QACF,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC,gBAAgB,IAAI,KAAK,CAAC;QAClD,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,IAAI,CAAC,SAAS,GAAG,EAAE,IAAI,IAAI,CAAC,SAAS,GAAG,KAAK,EAAE,CAAC;YAC3F,MAAM,IAAI,KAAK,CAAC,kEAAkE,CAAC,CAAC;QACtF,CAAC;QACD,IAAI,MAAM,CAAC,QAAQ,KAAK,SAAS,IAAI,MAAM,CAAC,QAAQ,KAAK,OAAO;YAAE,MAAM,IAAI,mBAAmB,CAAC,+CAA+C,CAAC,CAAC;QACjJ,IAAI,MAAM,CAAC,QAAQ,KAAK,SAAS,IAAI,OAAO,MAAM,CAAC,QAAQ,KAAK,QAAQ;YAAE,MAAM,IAAI,mBAAmB,CAAC,mCAAmC,CAAC,CAAC;QAC7I,IAAI,MAAM,CAAC,QAAQ,KAAK,SAAS,IAAI,MAAM,CAAC,QAAQ,KAAK,MAAM,IAAI,MAAM,CAAC,QAAQ,KAAK,OAAO;YAAE,MAAM,IAAI,KAAK,CAAC,wCAAwC,CAAC,CAAC;QAC1J,IAAI,MAAM,CAAC,IAAI,KAAK,SAAS,IAAI,CAAC,CAAC,MAAM,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,MAAM,CAAC,IAAI,GAAG,CAAC,IAAI,MAAM,CAAC,IAAI,GAAG,KAAK,CAAC;YAAE,MAAM,IAAI,KAAK,CAAC,0CAA0C,CAAC,CAAC;QAC7K,IAAI,MAAM,CAAC,IAAI,KAAK,SAAS;YAAE,MAAM,IAAI,KAAK,CAAC,4CAA4C,CAAC,CAAC;QAC7F,IAAI,OAAO,MAAM,CAAC,IAAI,KAAK,QAAQ,IAAI,CAAC,MAAM,CAAC,IAAI,IAAI,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC;YAAE,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,CAAC;QACvJ,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,MAAM,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC;QAC1G,IAAI,CAAC;YAAC,IAAI,CAAC,QAAQ,GAAG,IAAI,GAAG,CAAC,GAAG,MAAM,CAAC,QAAQ,IAAI,MAAM,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,MAAM,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;QAAC,CAAC;QAC/H,MAAM,CAAC;YAAC,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,CAAC;QAAC,CAAC;QAC3E,IAAI,CAAC,cAAc,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,GAAG,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IAC7G,CAAC;IAEM,SAAS;QACd,OAAO,CAAC,IAAI,CAAC,SAAS,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,OAAO,IAAI,IAAI,CAAC,OAAO,IAAI,CAAC,CAAC,IAAI,CAAC,YAAY,IAAI,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;IAChI,CAAC;IAEM,KAAK,CAAC,WAAW,CAAC,cAA4B;QACnD,IAAI,CAAC,YAAY,CAAC,cAAc,CAAC,CAAC;QAClC,IAAI,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,YAAY,EAAE,SAAS;YAAE,OAAO,eAAe,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QACzF,MAAM,UAAU,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC,CAAC;QAC5D,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,cAAc,CAAC,CAAC;QACpD,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,eAAe,CAAC,cAAc,CAAC,CAAC;QAChE,IAAI,CAAC,QAAQ,GAAG,EAAE,UAAU,EAAE,MAAM,EAAE,YAAY,EAAE,CAAC;QACrD,OAAO,eAAe,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IACxC,CAAC;IAEM,KAAK,CAAC,aAAa,CAAC,cAA4B;QACrD,IAAI,CAAC,YAAY,CAAC,cAAc,CAAC,CAAC;QAClC,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,SAAS,EAAE,cAAc,CAAC,CAAC;QAC9E,MAAM,UAAU,GAAG,IAAI,CAAC,aAAa,CAAC,GAAG,EAAE;YACzC,MAAM,IAAI,GAAG,qBAAqB,CAAC,QAAQ,CAAC,CAAC;YAC7C,IAAI,IAAI,CAAC,QAAQ,KAAK,SAAS,IAAI,IAAI,CAAC,QAAQ,KAAK,IAAI,CAAC,EAAE;gBAAE,MAAM,IAAI,wBAAwB,CAAC,0CAA0C,CAAC,CAAC;YAC7I,OAAO,IAAI,CAAC;QACd,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,QAAQ,GAAG,UAAU,CAAC,EAAE,CAAC;QAC9B,OAAO,UAAU,CAAC;IACpB,CAAC;IAEM,KAAK,CAAC,SAAS,CAAC,cAA4B;QACjD,IAAI,CAAC,YAAY,CAAC,cAAc,CAAC,CAAC;QAClC,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,kBAAkB,EAAE,SAAS,EAAE,cAAc,CAAC,CAAC;QACnF,MAAM,MAAM,GAAG,IAAI,CAAC,aAAa,CAAC,GAAG,EAAE,CAAC,iBAAiB,CAAC,QAAQ,CAAC,CAAC,CAAC;QACrE,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;QACpB,IAAI,IAAI,CAAC,QAAQ;YAAE,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC;QAC/D,OAAO,MAAM,CAAC;IAChB,CAAC;IAEM,KAAK,CAAC,eAAe,CAAC,cAA4B;QACvD,IAAI,CAAC,YAAY,CAAC,cAAc,CAAC,CAAC;QAClC,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,kBAAkB,EAAE,SAAS,EAAE,cAAc,CAAC,CAAC;QACnF,OAAO,IAAI,CAAC,aAAa,CAAC,GAAG,EAAE,CAAC,iBAAiB,CAAC,QAAQ,CAAC,CAAC,CAAC;IAC/D,CAAC;IAEM,KAAK,CAAC,eAAe,CAAC,WAAmB,EAAE,KAAc,EAAE,cAA4B;QAC5F,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,WAAW,CAAC,IAAI,WAAW,GAAG,CAAC,IAAI,OAAO,KAAK,KAAK,SAAS;YAAE,MAAM,IAAI,KAAK,CAAC,4EAA4E,CAAC,CAAC;QACvL,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,cAAc,CAAC,CAAC;QACxD,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,MAAM,CAAC,UAAU,WAAW,EAAE,CAAC,CAAC;YAAE,MAAM,IAAI,KAAK,CAAC,uDAAuD,CAAC,CAAC;QACxI,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,YAAY,EAAE,EAAE,EAAE,EAAE,WAAW,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,cAAc,CAAC,CAAC;QAChG,IAAI,CAAC,aAAa,CAAC,GAAG,EAAE;YACtB,IAAI,OAAO,MAAM,CAAC,MAAM,KAAK,SAAS;gBAAE,MAAM,IAAI,wBAAwB,CAAC,6CAA6C,CAAC,CAAC;QAC5H,CAAC,CAAC,CAAC;QACH,MAAM,IAAI,CAAC,SAAS,CAAC,cAAc,CAAC,CAAC;IACvC,CAAC;IAEM,KAAK,CAAC,SAAS,CAAC,UAAkD,EAAE,cAA4B;QACrG,IAAI,CAAC,YAAY,CAAC,cAAc,CAAC,CAAC;QAClC,IAAI,CAAC,IAAI,CAAC,QAAQ;YAAE,MAAM,IAAI,CAAC,WAAW,CAAC,cAAc,CAAC,CAAC;QAC3D,IAAI,eAAwD,CAAC;QAC7D,MAAM,YAAY,GAAG,IAAI,OAAO,CAAQ,CAAC,CAAC,EAAE,SAAS,EAAE,EAAE,GAAG,eAAe,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;QAC5F,MAAM,UAAU,GAAsB;YACpC,OAAO,EAAE,UAAU;YACnB,MAAM,EAAE,cAAc;YACtB,KAAK,EAAE,GAAG,EAAE;gBACV,eAAe,EAAE,CAAC,IAAI,YAAY,CAAC,gCAAgC,EAAE,YAAY,CAAC,CAAC,CAAC;gBACpF,KAAK,WAAW,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE;oBAC5B,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC,OAAO,EAAE,qCAAqC,CAAC,CAAC;oBACjE,IAAI,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,wBAAwB,CAAC,qCAAqC,CAAC,EAAE,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;gBAClI,CAAC,CAAC,CAAC;YACL,CAAC;SACF,CAAC;QACF,IAAI,OAAO,GAAG,KAAK,CAAC;QACpB,MAAM,WAAW,GAAG,KAAK,IAAmB,EAAE;YAC5C,IAAI,CAAC,OAAO,EAAE,CAAC;gBACb,OAAO,GAAG,IAAI,CAAC;gBACf,UAAU,CAAC,MAAM,EAAE,mBAAmB,CAAC,OAAO,EAAE,UAAU,CAAC,KAAK,CAAC,CAAC;gBAClE,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;YACtC,CAAC;YACD,IAAI,IAAI,CAAC,WAAW,CAAC,IAAI,KAAK,CAAC,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;gBACrD,MAAM,YAAY,GAAG,IAAI,CAAC,YAAY,CAAC;gBACvC,MAAM,YAAY,CAAC,IAAI,EAAE,CAAC;gBAC1B,IAAI,IAAI,CAAC,YAAY,KAAK,YAAY;oBAAE,IAAI,CAAC,YAAY,GAAG,SAAS,CAAC;YACxE,CAAC;QACH,CAAC,CAAC;QACF,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;QACjC,cAAc,EAAE,gBAAgB,CAAC,OAAO,EAAE,UAAU,CAAC,KAAK,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;QAC5E,IAAI,cAAc,EAAE,OAAO;YAAE,UAAU,CAAC,KAAK,EAAE,CAAC;QAChD,IAAI,CAAC;YACH,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,mBAAmB,EAAE,EAAE,YAAY,CAAC,CAAC,CAAC;YAC/D,IAAI,CAAC,YAAY,CAAC,cAAc,CAAC,CAAC;YAClC,eAAe,GAAG,SAAS,CAAC;YAC5B,OAAO,WAAW,CAAC;QACrB,CAAC;QAAC,OAAO,QAAQ,EAAE,CAAC;YAClB,MAAM,WAAW,EAAE,CAAC;YACpB,MAAM,QAAQ,CAAC;QACjB,CAAC;IACH,CAAC;IAEM,KAAK,CAAC,OAAO;QAClB,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;QACtB,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;QACrB,KAAK,MAAM,UAAU,IAAI,IAAI,CAAC,WAAW;YAAE,UAAU,CAAC,MAAM,EAAE,mBAAmB,CAAC,OAAO,EAAE,UAAU,CAAC,KAAK,CAAC,CAAC;QAC7G,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,CAAC;QACzB,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;QACtB,MAAM,IAAI,CAAC,YAAY,CAAC;QACxB,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;YACtB,MAAM,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;YAC/B,IAAI,CAAC,YAAY,GAAG,SAAS,CAAC;QAChC,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,mBAAmB;QAC/B,IAAI,IAAI,CAAC,YAAY,EAAE,UAAU,EAAE,CAAC;YAClC,MAAM,QAAQ,GAAG,IAAI,CAAC,YAAY,CAAC;YACnC,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAC;YACtB,IAAI,IAAI,CAAC,YAAY,KAAK,QAAQ;gBAAE,IAAI,CAAC,YAAY,GAAG,SAAS,CAAC;QACpE,CAAC;QACD,IAAI,CAAC,YAAY,EAAE,CAAC;QACpB,IAAI,CAAC,IAAI,CAAC,YAAY,IAAI,IAAI,CAAC,YAAY,CAAC,QAAQ,EAAE,CAAC;YACrD,IAAI,CAAC,IAAI,CAAC,QAAQ;gBAAE,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAC;YACxF,MAAM,GAAG,GAAG,IAAI,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;YAC3C,GAAG,CAAC,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,QAAQ,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC;YACpE,IAAI,CAAC,YAAY,GAAG,IAAI,kBAAkB,CAAC;gBACzC,GAAG,EAAE,GAAG,CAAC,QAAQ,EAAE;gBACnB,QAAQ,EAAE,IAAI,CAAC,QAAQ;gBACvB,MAAM,EAAE,OAAO,OAAO,CAAC,MAAM,CAAC,UAAU,EAAE,EAAE;gBAC5C,QAAQ,EAAE,IAAI,CAAC,MAAM,CAAC,QAAQ;gBAC9B,SAAS,EAAE,IAAI,CAAC,SAAS;gBACzB,WAAW,EAAE,IAAI,CAAC,cAAc;gBAChC,QAAQ,EAAE,CAAC,SAAS,EAAE,OAAO,EAAE,YAAY,EAAE,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,SAAS,EAAE,OAAO,EAAE,YAAY,CAAC;gBACnG,OAAO,EAAE,CAAC,QAAQ,EAAE,YAAY,EAAE,EAAE;oBAClC,IAAI,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,YAAY,EAAE,CAAC,CAAC;oBACvE,IAAI,QAAQ,CAAC,KAAK,KAAK,gBAAgB;wBAAE,KAAK,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,CAAC;gBACjF,CAAC;gBACD,cAAc,EAAE,CAAC,YAAY,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,cAAc,EAAE,SAAS,EAAE,YAAY,EAAE,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC;gBACrH,OAAO,EAAE,CAAC,QAAQ,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC;aAC5F,CAAC,CAAC;QACL,CAAC;QACD,MAAM,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,CAAC;IAClC,CAAC;IAEO,YAAY,CAAC,SAAwB,EAAE,OAAgB,EAAE,YAAoB;QACnF,IAAI,CAAC,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,SAAS;YAAE,OAAO;QAC7C,IAAI,CAAC,QAAQ,GAAG,EAAE,GAAG,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,iBAAiB,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC,EAAE,CAAC;QACvH,IAAI,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,eAAe,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,SAAS,EAAE,YAAY,EAAE,CAAC,CAAC;IACnG,CAAC;IAEO,IAAI,CAAC,QAA4B;QACvC,KAAK,MAAM,UAAU,IAAI,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC;YAC/C,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,UAAU,CAAC;gBAAE,SAAS;YAChD,IAAI,CAAC;gBAAC,UAAU,CAAC,OAAO,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC,CAAC;YAAC,CAAC;YACtD,MAAM,CAAC;gBACL,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC,OAAO,EAAE,oCAAoC,CAAC,CAAC;gBAChE,UAAU,CAAC,KAAK,EAAE,CAAC;gBACnB,IAAI,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,wBAAwB,CAAC,oCAAoC,CAAC,EAAE,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;YACjI,CAAC;QACH,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,aAAa,CAAC,YAAoB;QAC9C,IAAI,CAAC;YACH,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,eAAe,EAAE,CAAC;YAClD,IAAI,IAAI,CAAC,QAAQ,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC;gBACrC,IAAI,CAAC,QAAQ,GAAG,EAAE,GAAG,IAAI,CAAC,QAAQ,EAAE,YAAY,EAAE,CAAC;gBACnD,IAAI,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,eAAe,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,SAAS,EAAE,YAAY,EAAE,CAAC,CAAC;YACnG,CAAC;QACH,CAAC;QAAC,MAAM,CAAC;YACP,IAAI,CAAC,IAAI,CAAC,SAAS,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,OAAO;gBAAE,IAAI,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,wBAAwB,CAAC,sCAAsC,CAAC,EAAE,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;QACxL,CAAC;IACH,CAAC;IAEO,aAAa,CAAU,SAAwB;QACrD,IAAI,CAAC;YAAC,OAAO,SAAS,EAAE,CAAC;QAAC,CAAC;QAC3B,OAAO,QAAQ,EAAE,CAAC;YAAC,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;YAAC,MAAM,QAAQ,CAAC;QAAC,CAAC;IAC5D,CAAC;IAEO,KAAK,CAAC,OAAO,CAAC,SAAiB,EAAE,SAAmC,EAAE,cAA4B;QACxG,IAAI,CAAC,IAAI,CAAC,QAAQ;YAAE,MAAM,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC,CAAC;QAC7D,MAAM,EAAE,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;QAC5B,MAAM,MAAM,GAAG,oBAAoB,CAAC;QACpC,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,EAAE,cAAc,CAAC,CAAC;QACxH,OAAO,IAAI,CAAC,aAAa,CAAC,GAAG,EAAE,CAAC,oBAAoB,CAAC,KAAK,EAAE,EAAE,EAAE,IAAI,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC,CAAC;IAC1F,CAAC;IAEO,KAAK,CAAC,WAAW,CAAC,OAAe,EAAE,OAAiC,EAAE,cAA4B;QACxG,IAAI,CAAC,YAAY,CAAC,cAAc,CAAC,CAAC;QAClC,MAAM,QAAQ,GAAG,IAAI,eAAe,EAAE,CAAC;QACvC,IAAI,QAAQ,GAAG,KAAK,CAAC;QACrB,MAAM,KAAK,GAAG,UAAU,CAAC,GAAG,EAAE,GAAG,QAAQ,GAAG,IAAI,CAAC,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;QACvF,MAAM,MAAM,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC,cAAc,EAAE,GAAG,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;QACpH,MAAM,SAAS,GAAG,GAAU,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,wBAAwB,CAAC,2BAA2B,CAAC,CAAC,CAAC,CAAC,IAAI,YAAY,CAAC,2BAA2B,EAAE,YAAY,CAAC,CAAC;QAClK,IAAI,eAAwD,CAAC;QAC7D,MAAM,YAAY,GAAG,IAAI,OAAO,CAAQ,CAAC,CAAC,EAAE,SAAS,EAAE,EAAE,GAAG,eAAe,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;QAC5F,MAAM,WAAW,GAAG,GAAS,EAAE,CAAC,eAAe,EAAE,CAAC,SAAS,EAAE,CAAC,CAAC;QAC/D,MAAM,CAAC,gBAAgB,CAAC,OAAO,EAAE,WAAW,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;QAC9D,IAAI,MAAM,CAAC,OAAO;YAAE,WAAW,EAAE,CAAC;QAClC,MAAM,SAAS,GAAG,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,IAAI,EAAE;YAClD,IAAI,MAAM,CAAC,OAAO;gBAAE,MAAM,SAAS,EAAE,CAAC;YACtC,MAAM,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC;YACxC,IAAI,QAAQ,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;YACtE,IAAI,QAAQ,CAAC,MAAM,KAAK,GAAG,EAAE,CAAC;gBAC5B,MAAM,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC;gBAC9B,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ;oBAAE,MAAM,IAAI,mBAAmB,CAAC,4CAA4C,CAAC,CAAC;gBACvG,IAAI,CAAC,eAAe,GAAG,wBAAwB,CAAC,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,kBAAkB,CAAC,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;gBACzG,IAAI,CAAC,UAAU,GAAG,CAAC,CAAC;gBACpB,QAAQ,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;YACpE,CAAC;YACD,IAAI,CAAC,QAAQ,CAAC,EAAE,EAAE,CAAC;gBACjB,MAAM,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC;gBAC9B,IAAI,QAAQ,CAAC,MAAM,KAAK,GAAG;oBAAE,MAAM,IAAI,mBAAmB,CAAC,+BAA+B,CAAC,CAAC;gBAC5F,MAAM,IAAI,wBAAwB,CAAC,mCAAmC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC;YAC5F,CAAC;YACD,IAAI,CAAC,QAAQ,CAAC,IAAI;gBAAE,MAAM,IAAI,wBAAwB,CAAC,oCAAoC,CAAC,CAAC;YAC7F,MAAM,MAAM,GAAG,QAAQ,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC;YACzC,MAAM,MAAM,GAAiB,EAAE,CAAC;YAChC,IAAI,IAAI,GAAG,CAAC,CAAC;YACb,IAAI,CAAC;gBACH,OAAO,IAAI,EAAE,CAAC;oBACZ,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,MAAM,MAAM,CAAC,IAAI,EAAE,CAAC;oBAC5C,IAAI,IAAI;wBAAE,MAAM;oBAChB,IAAI,IAAI,KAAK,CAAC,UAAU,CAAC;oBACzB,IAAI,IAAI,GAAG,IAAI,GAAG,IAAI,EAAE,CAAC;wBACvB,MAAM,MAAM,CAAC,MAAM,EAAE,CAAC;wBACtB,MAAM,IAAI,wBAAwB,CAAC,yCAAyC,CAAC,CAAC;oBAChF,CAAC;oBACD,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;gBACrB,CAAC;YACH,CAAC;oBAAS,CAAC;gBAAC,MAAM,CAAC,WAAW,EAAE,CAAC;YAAC,CAAC;YACnC,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAY,CAAC;QACvE,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,YAAY,GAAG,SAAS,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,SAAS,EAAE,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;QACrE,IAAI,CAAC;YAAC,OAAO,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,YAAY,CAAC,CAAC,CAAC;QAAC,CAAC;QAC7D,OAAO,QAAQ,EAAE,CAAC;YAChB,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;YACrB,IAAI,MAAM,CAAC,OAAO;gBAAE,MAAM,SAAS,EAAE,CAAC;YACtC,IAAI,QAAQ,YAAY,mBAAmB,IAAI,QAAQ,YAAY,wBAAwB;gBAAE,MAAM,QAAQ,CAAC;YAC5G,MAAM,IAAI,wBAAwB,CAAC,iDAAiD,CAAC,CAAC;QACxF,CAAC;gBAAS,CAAC;YACT,YAAY,CAAC,KAAK,CAAC,CAAC;YACpB,MAAM,CAAC,mBAAmB,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;YACjD,eAAe,GAAG,SAAS,CAAC;QAC9B,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,SAAS,CAAC,OAAe,EAAE,SAAiB,EAAE,OAA4C,EAAE,SAAsB;QAC9H,MAAM,OAAO,GAA2B,EAAE,CAAC;QAC3C,IAAI,OAAO;YAAE,OAAO,CAAC,cAAc,CAAC,GAAG,kBAAkB,CAAC;QAC1D,IAAI,IAAI,CAAC,eAAe,IAAI,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC;YACjD,MAAM,MAAM,GAAG,kBAAkB,CAAC,IAAI,CAAC,eAAe,EAAE,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,EAAE,IAAI,CAAC,UAAU,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC;YACrH,OAAO,CAAC,aAAa,GAAG,mCAAmC,IAAI,CAAC,eAAe,CAAC,KAAK,aAAa,IAAI,CAAC,eAAe,CAAC,KAAK,WAAW,OAAO,mCAAmC,MAAM,CAAC,QAAQ,mBAAmB,MAAM,CAAC,EAAE,aAAa,MAAM,CAAC,MAAM,IAAI,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC,CAAC,aAAa,IAAI,CAAC,eAAe,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC;QAC7U,CAAC;QACD,OAAO,UAAU,CAAC,KAAK,CAAC,IAAI,GAAG,CAAC,OAAO,EAAE,IAAI,CAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,CAAC;IACtL,CAAC;IAEO,YAAY,CAAC,cAA4B;QAC/C,IAAI,IAAI,CAAC,SAAS;YAAE,MAAM,IAAI,KAAK,CAAC,mCAAmC,CAAC,CAAC;QACzE,IAAI,IAAI,CAAC,cAAc,CAAC,OAAO,IAAI,cAAc,EAAE,OAAO;YAAE,MAAM,IAAI,YAAY,CAAC,6BAA6B,EAAE,YAAY,CAAC,CAAC;IAClI,CAAC;CACF"}

package/dist_ts/integrations/shelly/shelly.classes.configflow.js

@@ -1,3 +1,4 @@
+import { ShellyClient } from './shelly.classes.client.js';
 export class ShellyConfigFlow {
     async start(candidateArg, contextArg) {
         void contextArg;
@@ -15,18 +16,35 @@ export class ShellyConfigFlow {
                 { name: 'username', label: 'Username', type: 'text' },
                 { name: 'password', label: 'Password', type: 'password' },
             ],
-            submit: async (valuesArg) => ({
-                kind: 'done',
-                title: 'Shelly configured',
-                config: {
-                    host: String(valuesArg.host || candidateArg.host || ''),
-                    port: typeof valuesArg.port === 'number' ? valuesArg.port : candidateArg.port || 80,
+            submit: async (valuesArg) => {
+                if (valuesArg.protocol !== undefined && !['http', 'https'].includes(String(valuesArg.protocol)) ||
+                    valuesArg.host !== undefined && typeof valuesArg.host !== 'string' ||
+                    valuesArg.port !== undefined && typeof valuesArg.port !== 'number' ||
+                    valuesArg.username !== undefined && valuesArg.username !== 'admin' ||
+                    valuesArg.password !== undefined && typeof valuesArg.password !== 'string') {
+                    return { kind: 'error', error: 'Invalid Shelly connection settings.' };
+                }
+                const config = {
+                    host: typeof valuesArg.host === 'string' ? valuesArg.host : candidateArg.host ?? '',
+                    port: typeof valuesArg.port === 'number' ? valuesArg.port : candidateArg.port,
                     protocol: valuesArg.protocol === 'https' ? 'https' : 'http',
-                    username: String(valuesArg.username || 'admin'),
-                    password: valuesArg.password ? String(valuesArg.password) : undefined,
-                },
-            }),
+                    username: 'admin',
+                    password: typeof valuesArg.password === 'string' ? valuesArg.password : undefined,
+                };
+                let client;
+                try {
+                    client = new ShellyClient(config);
+                    await client.getSnapshot();
+                    return { kind: 'done', title: 'Shelly configured', config };
+                }
+                catch {
+                    return { kind: 'error', error: 'Could not validate the Shelly Gen2/3 connection and credentials.' };
+                }
+                finally {
+                    await client?.destroy();
+                }
+            },
         };
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2hlbGx5LmNsYXNzZXMuY29uZmlnZmxvdy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3RzL2ludGVncmF0aW9ucy9zaGVsbHkvc2hlbGx5LmNsYXNzZXMuY29uZmlnZmxvdy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFHQSxNQUFNLE9BQU8sZ0JBQWdCO0lBQ3BCLEtBQUssQ0FBQyxLQUFLLENBQUMsWUFBaUMsRUFBRSxVQUE4QjtRQUNsRixLQUFLLFVBQVUsQ0FBQztRQUNoQixPQUFPO1lBQ0wsSUFBSSxFQUFFLE1BQU07WUFDWixLQUFLLEVBQUUsZ0JBQWdCO1lBQ3ZCLFdBQVcsRUFBRSwwR0FBMEc7WUFDdkgsTUFBTSxFQUFFO2dCQUNOLEVBQUUsSUFBSSxFQUFFLE1BQU0sRUFBRSxLQUFLLEVBQUUsTUFBTSxFQUFFLElBQUksRUFBRSxNQUFNLEVBQUUsUUFBUSxFQUFFLElBQUksRUFBRTtnQkFDN0QsRUFBRSxJQUFJLEVBQUUsTUFBTSxFQUFFLEtBQUssRUFBRSxNQUFNLEVBQUUsSUFBSSxFQUFFLFFBQVEsRUFBRTtnQkFDL0MsRUFBRSxJQUFJLEVBQUUsVUFBVSxFQUFFLEtBQUssRUFBRSxVQUFVLEVBQUUsSUFBSSxFQUFFLFFBQVEsRUFBRSxPQUFPLEVBQUU7d0JBQzlELEVBQUUsS0FBSyxFQUFFLE1BQU0sRUFBRSxLQUFLLEVBQUUsTUFBTSxFQUFFO3dCQUNoQyxFQUFFLEtBQUssRUFBRSxPQUFPLEVBQUUsS0FBSyxFQUFFLE9BQU8sRUFBRTtxQkFDbkMsRUFBRTtnQkFDSCxFQUFFLElBQUksRUFBRSxVQUFVLEVBQUUsS0FBSyxFQUFFLFVBQVUsRUFBRSxJQUFJLEVBQUUsTUFBTSxFQUFFO2dCQUNyRCxFQUFFLElBQUksRUFBRSxVQUFVLEVBQUUsS0FBSyxFQUFFLFVBQVUsRUFBRSxJQUFJLEVBQUUsVUFBVSxFQUFFO2FBQzFEO1lBQ0QsTUFBTSxFQUFFLEtBQUssRUFBRSxTQUFTLEVBQUUsRUFBRSxDQUFDLENBQUM7Z0JBQzVCLElBQUksRUFBRSxNQUFNO2dCQUNaLEtBQUssRUFBRSxtQkFBbUI7Z0JBQzFCLE1BQU0sRUFBRTtvQkFDTixJQUFJLEVBQUUsTUFBTSxDQUFDLFNBQVMsQ0FBQyxJQUFJLElBQUksWUFBWSxDQUFDLElBQUksSUFBSSxFQUFFLENBQUM7b0JBQ3ZELElBQUksRUFBRSxPQUFPLFNBQVMsQ0FBQyxJQUFJLEtBQUssUUFBUSxDQUFDLENBQUMsQ0FBQyxTQUFTLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxZQUFZLENBQUMsSUFBSSxJQUFJLEVBQUU7b0JBQ25GLFFBQVEsRUFBRSxTQUFTLENBQUMsUUFBUSxLQUFLLE9BQU8sQ0FBQyxDQUFDLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxNQUFNO29CQUMzRCxRQUFRLEVBQUUsTUFBTSxDQUFDLFNBQVMsQ0FBQyxRQUFRLElBQUksT0FBTyxDQUFDO29CQUMvQyxRQUFRLEVBQUUsU0FBUyxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUMsTUFBTSxDQUFDLFNBQVMsQ0FBQyxRQUFRLENBQUMsQ0FBQyxDQUFDLENBQUMsU0FBUztpQkFDdEU7YUFDRixDQUFDO1NBQ0gsQ0FBQztJQUNKLENBQUM7Q0FDRiJ9
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/integrations/shelly/shelly.classes.integration.d.ts

@@ -5,7 +5,7 @@ import type { IShellyConfig } from './shelly.types.js';
 export declare class ShellyIntegration extends BaseIntegration<IShellyConfig> {
     readonly domain = "shelly";
     readonly displayName = "Shelly";
-    readonly status: "control-runtime";
+    readonly status: 'control-runtime';
     readonly discoveryDescriptor: import("../../index.js").DiscoveryDescriptor;
     readonly configFlow: ShellyConfigFlow;
     readonly metadata: {
@@ -16,6 +16,9 @@ export declare class ShellyIntegration extends BaseIntegration<IShellyConfig> {
         iotClass: string;
         qualityScale: string;
     };
+    private readonly runtimes;
+    private readonly pendingClients;
+    private destroyed;
     setup(configArg: IShellyConfig, contextArg: IIntegrationSetupContext): Promise<IIntegrationRuntime>;
     destroy(): Promise<void>;
 }