@smarthome.exchange/integrations 0.2.0 → 1.0.0

package/dist_ts/integrations/deconz/deconz.classes.client.d.ts

@@ -1,28 +1,37 @@
 import type { IDeconzConfig, IDeconzGatewayConfig, IDeconzGroupActionPatch, IDeconzLightStatePatch, IDeconzSensorConfigPatch, IDeconzSensorStatePatch, IDeconzSnapshot, IDeconzWebsocketEvent } from './deconz.types.js';
+export declare class DeconzRequestError extends Error {
+    readonly apiErrorType?: number | undefined;
+    constructor(messageArg: string, apiErrorType?: number | undefined);
+}
 export declare class DeconzClient {
+    private readonly abortSignal?;
     private readonly config;
-    constructor(config: IDeconzConfig);
-    getSnapshot(): Promise<IDeconzSnapshot>;
-    getGatewayConfig(): Promise<IDeconzGatewayConfig>;
-    setLightState(lightIdArg: string, stateArg: IDeconzLightStatePatch): Promise<void>;
-    setGroupState(groupIdArg: string, actionArg: IDeconzGroupActionPatch): Promise<void>;
-    setSensorConfig(sensorIdArg: string, configArg: IDeconzSensorConfigPatch): Promise<void>;
-    setSensorState(sensorIdArg: string, stateArg: IDeconzSensorStatePatch): Promise<void>;
-    recallScene(groupIdArg: string, sceneIdArg: string): Promise<void>;
-    put<TResult = unknown>(pathArg: string, dataArg: Record<string, unknown>): Promise<TResult>;
-    post<TResult = unknown>(pathArg: string, dataArg: Record<string, unknown>): Promise<TResult>;
-    subscribeToEvents(handlerArg: (eventArg: IDeconzWebsocketEvent) => void): Promise<() => Promise<void>>;
+    private readonly endpoint?;
+    private readonly timeoutMs;
+    private readonly lifetime;
+    private readonly operations;
+    private readonly subscriptions;
+    private streamHealthy;
+    private gatewayHealthy;
+    private gatewayId?;
+    constructor(configArg: IDeconzConfig, abortSignal?: AbortSignal | undefined);
+    get isHealthy(): boolean;
+    getSnapshot(abortSignalArg?: AbortSignal): Promise<IDeconzSnapshot>;
+    getGatewayConfig(abortSignalArg?: AbortSignal): Promise<IDeconzGatewayConfig>;
+    acquireApiKey(deviceTypeArg?: string, abortSignalArg?: AbortSignal): Promise<string>;
+    setLightState(idArg: string, stateArg: IDeconzLightStatePatch, signalArg?: AbortSignal): Promise<void>;
+    setGroupState(idArg: string, actionArg: IDeconzGroupActionPatch, signalArg?: AbortSignal): Promise<void>;
+    setSensorConfig(idArg: string, configArg: IDeconzSensorConfigPatch, signalArg?: AbortSignal): Promise<void>;
+    setSensorState(idArg: string, stateArg: IDeconzSensorStatePatch, signalArg?: AbortSignal): Promise<void>;
+    recallScene(groupIdArg: string, sceneIdArg: string, signalArg?: AbortSignal): Promise<void>;
+    put<TResult = unknown>(pathArg: string, dataArg: Record<string, unknown>, signalArg?: AbortSignal): Promise<TResult>;
+    post<TResult = unknown>(pathArg: string, dataArg: Record<string, unknown>, signalArg?: AbortSignal): Promise<TResult>;
+    subscribeToEvents(handlerArg: (eventArg: IDeconzWebsocketEvent) => void, abortSignalArg?: AbortSignal, errorHandlerArg?: (errorArg: Error) => void): Promise<() => Promise<void>>;
     destroy(): Promise<void>;
     private requestJson;
-    private baseUrl;
-    private apiPath;
-    private canUseHttp;
-    private resolveWebSocketPort;
-    private parseWebSocketMessage;
-    private applyLightState;
-    private applyGroupState;
-    private applySensorConfig;
-    private applySensorState;
-    private findApiError;
-    private isRecord;
+    private fetchJson;
+    private assertWriteAcknowledgement;
+    private assertActive;
+    private assertGatewayIdentity;
+    private resourceId;
 }

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

@@ -1,190 +1,339 @@
+import { deconzEndpoint, deconzGatewayConfig, deconzGroupActionPatch, deconzLightStatePatch, deconzPort, deconzSensorConfigPatch, deconzSensorStatePatch, deconzSnapshot, deconzWebsocketEvent, isDeconzRecord } from './deconz.validation.js';
+export class DeconzRequestError extends Error {
+    apiErrorType;
+    constructor(messageArg, apiErrorType) {
+        super(messageArg);
+        this.apiErrorType = apiErrorType;
+    }
+}
 export class DeconzClient {
+    abortSignal;
     config;
-    constructor(config) {
-        this.config = config;
-    }
-    async getSnapshot() {
-        if (this.config.snapshot) {
-            return this.config.snapshot;
+    endpoint;
+    timeoutMs;
+    lifetime = new AbortController();
+    operations = new Set();
+    subscriptions = new Set();
+    streamHealthy = true;
+    gatewayHealthy = false;
+    gatewayId;
+    constructor(configArg, abortSignal) {
+        this.abortSignal = abortSignal;
+        this.config = structuredClone(configArg);
+        const config = this.config;
+        if (config.snapshot && config.host !== undefined)
+            throw new Error('deCONZ snapshot fixtures cannot be combined with a live endpoint.');
+        this.timeoutMs = config.requestTimeoutMs ?? 15000;
+        if (!Number.isInteger(this.timeoutMs) || this.timeoutMs < 1 || this.timeoutMs > 2147483647) {
+            throw new Error('deCONZ requestTimeoutMs must be a positive timer-safe integer.');
         }
-        return this.requestJson('GET', '');
-    }
-    async getGatewayConfig() {
-        if (this.config.snapshot?.config) {
-            return this.config.snapshot.config;
+        if (config.host !== undefined)
+            this.endpoint = deconzEndpoint(config);
+        if (!config.snapshot && !this.endpoint)
+            throw new Error('deCONZ host is required.');
+        if (config.apiKey !== undefined && (typeof config.apiKey !== 'string' || !config.apiKey.trim() || config.apiKey.trim() !== config.apiKey)) {
+            throw new Error('deCONZ API key must be a non-empty string.');
         }
-        return this.requestJson('GET', '/config');
+        if (config.websocketPort !== undefined)
+            deconzPort(config.websocketPort);
+        if (config.bridgeId !== undefined && (typeof config.bridgeId !== 'string' || !config.bridgeId))
+            throw new Error('Invalid deCONZ configured gateway identity.');
+        if (config.enableWebSocket !== undefined && typeof config.enableWebSocket !== 'boolean')
+            throw new Error('Invalid deCONZ WebSocket setting.');
     }
-    async setLightState(lightIdArg, stateArg) {
-        if (this.canUseHttp()) {
-            await this.put(`/lights/${encodeURIComponent(lightIdArg)}/state`, stateArg);
-        }
-        this.applyLightState(lightIdArg, stateArg);
+    get isHealthy() {
+        return !this.lifetime.signal.aborted && !this.abortSignal?.aborted && this.streamHealthy && this.gatewayHealthy;
     }
-    async setGroupState(groupIdArg, actionArg) {
-        if (this.canUseHttp()) {
-            await this.put(`/groups/${encodeURIComponent(groupIdArg)}/action`, actionArg);
+    async getSnapshot(abortSignalArg) {
+        try {
+            this.assertActive(abortSignalArg);
+            const snapshot = deconzSnapshot(this.config.snapshot ? structuredClone(this.config.snapshot) : await this.requestJson('GET', '', undefined, abortSignalArg));
+            this.assertGatewayIdentity(snapshot.config);
+            this.gatewayHealthy = true;
+            return snapshot;
         }
-        this.applyGroupState(groupIdArg, actionArg);
-    }
-    async setSensorConfig(sensorIdArg, configArg) {
-        if (this.canUseHttp()) {
-            await this.put(`/sensors/${encodeURIComponent(sensorIdArg)}/config`, configArg);
+        catch (error) {
+            this.gatewayHealthy = false;
+            throw error;
         }
-        this.applySensorConfig(sensorIdArg, configArg);
     }
-    async setSensorState(sensorIdArg, stateArg) {
-        if (this.canUseHttp()) {
-            await this.put(`/sensors/${encodeURIComponent(sensorIdArg)}/state`, stateArg);
+    async getGatewayConfig(abortSignalArg) {
+        try {
+            this.assertActive(abortSignalArg);
+            const config = deconzGatewayConfig(this.config.snapshot ? this.config.snapshot.config : await this.requestJson('GET', '/config', undefined, abortSignalArg));
+            this.assertGatewayIdentity(config);
+            this.gatewayHealthy = true;
+            return config;
         }
-        this.applySensorState(sensorIdArg, stateArg);
-    }
-    async recallScene(groupIdArg, sceneIdArg) {
-        if (this.canUseHttp()) {
-            await this.put(`/groups/${encodeURIComponent(groupIdArg)}/scenes/${encodeURIComponent(sceneIdArg)}/recall`, {});
+        catch (error) {
+            this.gatewayHealthy = false;
+            throw error;
         }
-        const group = this.config.snapshot?.groups[groupIdArg];
-        if (group) {
-            group.action = { ...group.action, scene: sceneIdArg };
+    }
+    async acquireApiKey(deviceTypeArg = 'smarthome.exchange', abortSignalArg) {
+        if (typeof deviceTypeArg !== 'string' || !deviceTypeArg || deviceTypeArg.length > 40)
+            throw new Error('Invalid deCONZ client name.');
+        const result = await this.requestJson('POST', '', { devicetype: deviceTypeArg }, abortSignalArg, true);
+        if (!Array.isArray(result) || result.length !== 1 || !isDeconzRecord(result[0]) || !isDeconzRecord(result[0].success) || typeof result[0].success.username !== 'string' || !result[0].success.username.trim()) {
+            throw new Error('Invalid deCONZ pairing response.');
         }
+        return result[0].success.username;
     }
-    async put(pathArg, dataArg) {
-        return this.requestJson('PUT', pathArg, dataArg);
+    async setLightState(idArg, stateArg, signalArg) {
+        const patch = deconzLightStatePatch(stateArg);
+        await this.put(`/lights/${this.resourceId(idArg)}/state`, patch, signalArg);
     }
-    async post(pathArg, dataArg) {
-        return this.requestJson('POST', pathArg, dataArg);
+    async setGroupState(idArg, actionArg, signalArg) {
+        const patch = deconzGroupActionPatch(actionArg);
+        await this.put(`/groups/${this.resourceId(idArg)}/action`, patch, signalArg);
     }
-    async subscribeToEvents(handlerArg) {
-        if (this.config.enableWebSocket === false || !this.config.host) {
-            return async () => { };
-        }
-        const WebSocketCtor = globalThis.WebSocket;
-        if (!WebSocketCtor) {
-            return async () => { };
-        }
-        const websocketPort = await this.resolveWebSocketPort();
-        if (!websocketPort) {
+    async setSensorConfig(idArg, configArg, signalArg) {
+        const patch = deconzSensorConfigPatch(configArg);
+        await this.put(`/sensors/${this.resourceId(idArg)}/config`, patch, signalArg);
+    }
+    async setSensorState(idArg, stateArg, signalArg) {
+        const snapshot = await this.getSnapshot(signalArg);
+        if (!snapshot.sensors[idArg]?.type?.startsWith('CLIP'))
+            throw new Error('deCONZ sensor state is writable only for CLIP sensors.');
+        deconzSensorStatePatch(snapshot.sensors[idArg].type, stateArg);
+        await this.put(`/sensors/${this.resourceId(idArg)}/state`, stateArg, signalArg);
+    }
+    async recallScene(groupIdArg, sceneIdArg, signalArg) {
+        await this.put(`/groups/${this.resourceId(groupIdArg)}/scenes/${this.resourceId(sceneIdArg)}/recall`, {}, signalArg);
+    }
+    async put(pathArg, dataArg, signalArg) {
+        const result = await this.requestJson('PUT', pathArg, dataArg, signalArg);
+        this.assertWriteAcknowledgement(result, pathArg);
+        return result;
+    }
+    async post(pathArg, dataArg, signalArg) {
+        const result = await this.requestJson('POST', pathArg, dataArg, signalArg);
+        this.assertWriteAcknowledgement(result);
+        return result;
+    }
+    async subscribeToEvents(handlerArg, abortSignalArg, errorHandlerArg) {
+        this.assertActive(abortSignalArg);
+        if (this.config.enableWebSocket === false)
             return async () => { };
-        }
-        const socket = new WebSocketCtor(`ws://${this.config.host}:${websocketPort}`);
-        const listener = (messageArg) => {
-            const event = this.parseWebSocketMessage(messageArg.data);
-            if (event) {
-                handlerArg(event);
+        if (!this.endpoint)
+            throw new Error('deCONZ WebSocket requires a live gateway endpoint.');
+        if (typeof globalThis.WebSocket !== 'function')
+            throw new Error('deCONZ requires native WebSocket support.');
+        const port = this.config.websocketPort ?? (await this.getGatewayConfig(abortSignalArg)).websocketport;
+        this.assertActive(abortSignalArg);
+        if (port === undefined)
+            throw new Error('deCONZ gateway did not advertise a WebSocket port.');
+        const websocketUrl = new URL(this.endpoint);
+        websocketUrl.protocol = 'ws:';
+        websocketUrl.port = String(deconzPort(port));
+        const socket = new WebSocket(websocketUrl);
+        const signal = AbortSignal.any([this.lifetime.signal, ...(this.abortSignal ? [this.abortSignal] : []), ...(abortSignalArg ? [abortSignalArg] : [])]);
+        let closing = false;
+        let closePromise;
+        let opened = false;
+        let resolveOpen = () => { };
+        let rejectOpen = () => { };
+        const ready = new Promise((resolveArg, rejectArg) => { resolveOpen = resolveArg; rejectOpen = rejectArg; });
+        const report = (messageArg) => {
+            this.streamHealthy = false;
+            const error = new Error(messageArg);
+            if (!opened)
+                rejectOpen(error);
+            else if (!closing)
+                errorHandlerArg?.(error);
+        };
+        const message = (eventArg) => {
+            if (closing || signal.aborted)
+                return;
+            let event;
+            try {
+                if (typeof eventArg.data !== 'string' || eventArg.data.length > 1048576)
+                    throw new Error('Invalid message.');
+                event = deconzWebsocketEvent(JSON.parse(eventArg.data));
+            }
+            catch {
+                report('deCONZ WebSocket received an invalid event.');
+                return;
             }
+            handlerArg(event);
         };
-        if (socket.addEventListener) {
-            socket.addEventListener('message', listener);
-        }
-        else {
-            socket.onmessage = listener;
-        }
-        return async () => {
-            socket.close();
+        const onOpen = () => { opened = true; this.streamHealthy = true; resolveOpen(); };
+        const onError = () => report('deCONZ WebSocket connection failed.');
+        const onClose = () => {
+            if (!closing)
+                report('deCONZ WebSocket connection closed.');
+            cleanup();
         };
-    }
-    async destroy() { }
-    async requestJson(methodArg, pathArg, dataArg) {
-        if (!this.canUseHttp()) {
-            throw new Error('deCONZ host and apiKey are required when snapshot data is not provided.');
+        const onAbort = () => {
+            rejectOpen(new Error('deCONZ subscription cancelled.'));
+            void close().catch(() => {
+                this.streamHealthy = false;
+                errorHandlerArg?.(new Error('deCONZ WebSocket cleanup failed.'));
+            });
+        };
+        const cleanup = () => {
+            socket.removeEventListener('open', onOpen);
+            socket.removeEventListener('message', message);
+            socket.removeEventListener('error', onError);
+            socket.removeEventListener('close', onClose);
+            signal.removeEventListener('abort', onAbort);
+            this.subscriptions.delete(close);
+        };
+        const close = () => {
+            if (closePromise)
+                return closePromise;
+            closing = true;
+            socket.removeEventListener('message', message);
+            if (socket.readyState === WebSocket.CLOSED) {
+                cleanup();
+                return Promise.resolve();
+            }
+            closePromise = new Promise((resolveArg, rejectArg) => {
+                const closed = () => { clearTimeout(timer); socket.removeEventListener('close', closed); cleanup(); resolveArg(); };
+                const timer = setTimeout(() => {
+                    socket.removeEventListener('close', closed);
+                    closePromise = undefined;
+                    rejectArg(new Error('deCONZ WebSocket close timed out.'));
+                }, this.timeoutMs);
+                socket.addEventListener('close', closed, { once: true });
+                socket.close();
+            });
+            return closePromise;
+        };
+        this.subscriptions.add(close);
+        socket.addEventListener('open', onOpen, { once: true });
+        socket.addEventListener('message', message);
+        socket.addEventListener('error', onError);
+        socket.addEventListener('close', onClose, { once: true });
+        signal.addEventListener('abort', onAbort, { once: true });
+        const timer = setTimeout(() => rejectOpen(new Error('deCONZ WebSocket open timed out.')), this.timeoutMs);
+        try {
+            if (signal.aborted)
+                onAbort();
+            await ready;
+            this.assertActive(abortSignalArg);
+            return close;
         }
-        const response = await globalThis.fetch(`${this.baseUrl()}${this.apiPath(pathArg)}`, {
-            method: methodArg,
-            headers: dataArg ? { 'content-type': 'application/json' } : undefined,
-            body: dataArg ? JSON.stringify(dataArg) : undefined,
-        });
-        const text = await response.text();
-        const parsed = text ? JSON.parse(text) : undefined;
-        if (!response.ok) {
-            throw new Error(`deCONZ request ${methodArg} ${pathArg || '/'} failed with HTTP ${response.status}: ${text}`);
+        catch (error) {
+            await close();
+            throw error;
         }
-        const apiError = this.findApiError(parsed);
-        if (apiError) {
-            throw new Error(`deCONZ request ${methodArg} ${pathArg || '/'} failed: ${apiError}`);
+        finally {
+            clearTimeout(timer);
         }
-        return parsed;
-    }
-    baseUrl() {
-        const protocol = this.config.protocol || 'http';
-        const port = this.config.port ?? (protocol === 'https' ? 443 : 80);
-        const defaultPort = protocol === 'https' ? 443 : 80;
-        return `${protocol}://${this.config.host}${port === defaultPort ? '' : `:${port}`}`;
     }
-    apiPath(pathArg) {
-        const suffix = pathArg.startsWith('/') ? pathArg : pathArg ? `/${pathArg}` : '';
-        return `/api/${encodeURIComponent(String(this.config.apiKey))}${suffix}`;
+    async destroy() {
+        this.lifetime.abort();
+        const results = await Promise.allSettled([...this.subscriptions].map((closeArg) => closeArg()));
+        await Promise.allSettled([...this.operations]);
+        const failures = results.filter((resultArg) => resultArg.status === 'rejected');
+        if (failures.length)
+            throw new AggregateError(failures.map((failureArg) => failureArg.reason), 'deCONZ cleanup failed.');
     }
-    canUseHttp() {
-        return Boolean(this.config.host && this.config.apiKey);
+    requestJson(methodArg, pathArg, dataArg, signalArg, pairingArg = false) {
+        this.assertActive(signalArg);
+        if (!this.endpoint || !pairingArg && !this.config.apiKey)
+            throw new Error('deCONZ live requests require a host and API key.');
+        if (pathArg && (!/^\/[a-z0-9/%_-]+$/i.test(pathArg) || pathArg.includes('..')))
+            throw new Error('Invalid deCONZ request path.');
+        const url = new URL(this.endpoint);
+        url.pathname = pairingArg ? '/api' : `/api/${encodeURIComponent(this.config.apiKey)}${pathArg}`;
+        const operation = this.fetchJson(url, methodArg, dataArg, signalArg);
+        this.operations.add(operation);
+        void operation.then(() => this.operations.delete(operation), () => this.operations.delete(operation));
+        return operation;
     }
-    async resolveWebSocketPort() {
-        if (this.config.websocketPort) {
-            return this.config.websocketPort;
-        }
-        if (this.config.snapshot?.config?.websocketport) {
-            return this.config.snapshot.config.websocketport;
-        }
-        if (!this.canUseHttp()) {
-            return undefined;
-        }
-        return (await this.getGatewayConfig()).websocketport;
-    }
-    parseWebSocketMessage(dataArg) {
-        if (typeof dataArg === 'string') {
-            return JSON.parse(dataArg);
+    async fetchJson(urlArg, methodArg, dataArg, signalArg) {
+        const deadline = new AbortController();
+        const timer = setTimeout(() => deadline.abort(), this.timeoutMs);
+        const signal = AbortSignal.any([deadline.signal, this.lifetime.signal, ...(this.abortSignal ? [this.abortSignal] : []), ...(signalArg ? [signalArg] : [])]);
+        try {
+            const response = await fetch(urlArg, { method: methodArg, redirect: 'error', signal, headers: dataArg ? { 'content-type': 'application/json' } : undefined, body: dataArg ? JSON.stringify(dataArg) : undefined });
+            if (!response.ok) {
+                await response.body?.cancel();
+                throw new DeconzRequestError(`deCONZ request failed with HTTP ${response.status}.`);
+            }
+            const reader = response.body?.getReader();
+            if (!reader)
+                throw new DeconzRequestError('Empty deCONZ response.');
+            const chunks = [];
+            let length = 0;
+            try {
+                while (true) {
+                    const chunk = await reader.read();
+                    if (chunk.done)
+                        break;
+                    length += chunk.value.length;
+                    if (length > 8388608) {
+                        await reader.cancel();
+                        throw new DeconzRequestError('deCONZ response exceeds the size limit.');
+                    }
+                    chunks.push(chunk.value);
+                }
+            }
+            finally {
+                reader.releaseLock();
+            }
+            const bytes = new Uint8Array(length);
+            let offset = 0;
+            for (const chunk of chunks) {
+                bytes.set(chunk, offset);
+                offset += chunk.length;
+            }
+            let result;
+            try {
+                result = JSON.parse(new TextDecoder().decode(bytes));
+            }
+            catch {
+                throw new DeconzRequestError('Invalid deCONZ JSON response.');
+            }
+            if (Array.isArray(result)) {
+                for (const item of result) {
+                    if (isDeconzRecord(item) && isDeconzRecord(item.error)) {
+                        const type = typeof item.error.type === 'number' && Number.isInteger(item.error.type) ? item.error.type : undefined;
+                        throw new DeconzRequestError('deCONZ rejected the request.', type);
+                    }
+                }
+            }
+            return result;
         }
-        if (this.isRecord(dataArg)) {
-            return dataArg;
+        catch (error) {
+            if (signal.aborted)
+                throw new DeconzRequestError(deadline.signal.aborted ? 'deCONZ request timed out.' : 'deCONZ request cancelled.');
+            if (error instanceof DeconzRequestError)
+                throw error;
+            throw new DeconzRequestError('deCONZ network request failed.');
         }
-        return undefined;
-    }
-    applyLightState(lightIdArg, stateArg) {
-        const light = this.config.snapshot?.lights[lightIdArg];
-        if (light) {
-            light.state = { ...light.state, ...stateArg };
+        finally {
+            clearTimeout(timer);
         }
     }
-    applyGroupState(groupIdArg, actionArg) {
-        const group = this.config.snapshot?.groups[groupIdArg];
-        if (!group) {
-            return;
+    assertWriteAcknowledgement(valueArg, pathArg) {
+        const entries = Array.isArray(valueArg) ? valueArg : [valueArg];
+        if (!entries.length || entries.some((entryArg) => !isDeconzRecord(entryArg) || !isDeconzRecord(entryArg.success) || !Object.keys(entryArg.success).length)) {
+            throw new Error('Invalid deCONZ write acknowledgement.');
         }
-        group.action = { ...group.action, ...actionArg };
-        if (typeof actionArg.on === 'boolean') {
-            group.state = {
-                ...group.state,
-                any_on: actionArg.on,
-                all_on: actionArg.on,
-            };
+        if (pathArg && entries.some((entryArg) => isDeconzRecord(entryArg) && isDeconzRecord(entryArg.success) && Object.keys(entryArg.success).some((addressArg) => addressArg !== pathArg && !addressArg.startsWith(`${pathArg}/`)))) {
+            throw new Error('deCONZ write acknowledgement addresses a different resource.');
         }
     }
-    applySensorConfig(sensorIdArg, configArg) {
-        const sensor = this.config.snapshot?.sensors[sensorIdArg];
-        if (sensor) {
-            sensor.config = { ...sensor.config, ...configArg };
-        }
-    }
-    applySensorState(sensorIdArg, stateArg) {
-        const sensor = this.config.snapshot?.sensors[sensorIdArg];
-        if (sensor) {
-            sensor.state = { ...sensor.state, ...stateArg };
-        }
+    assertActive(signalArg) {
+        if (this.lifetime.signal.aborted || this.abortSignal?.aborted || signalArg?.aborted)
+            throw new Error('deCONZ operation cancelled.');
     }
-    findApiError(valueArg) {
-        if (!Array.isArray(valueArg)) {
-            return undefined;
-        }
-        for (const item of valueArg) {
-            if (!this.isRecord(item) || !this.isRecord(item.error)) {
-                continue;
-            }
-            const description = item.error.description;
-            return typeof description === 'string' ? description : JSON.stringify(item.error);
+    assertGatewayIdentity(configArg) {
+        const identity = (configArg.bridgeid ?? configArg.uuid)?.toLowerCase();
+        const expected = this.config.bridgeId?.toLowerCase();
+        if (expected && configArg.bridgeid?.toLowerCase() !== expected && configArg.uuid?.toLowerCase() !== expected || this.gatewayId && identity !== this.gatewayId) {
+            this.streamHealthy = false;
+            throw new Error('deCONZ gateway identity does not match configuration.');
         }
-        return undefined;
+        this.gatewayId = identity;
     }
-    isRecord(valueArg) {
-        return typeof valueArg === 'object' && valueArg !== null && !Array.isArray(valueArg);
+    resourceId(valueArg) {
+        if (typeof valueArg !== 'string' || !/^[a-z0-9_-]+$/i.test(valueArg))
+            throw new Error('Invalid deCONZ resource identity.');
+        return encodeURIComponent(valueArg);
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"deconz.classes.client.js","sourceRoot":"","sources":["../../../ts/integrations/deconz/deconz.classes.client.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"deconz.classes.client.js","sourceRoot":"","sources":["../../../ts/integrations/deconz/deconz.classes.client.ts"],"names":[],"mappings":"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"}