@smarthome.exchange/integrations 0.2.0 → 2.0.0

package/dist_ts/integrations/webostv/webostv.classes.integration.js

@@ -1,15 +1,146 @@
-import { SimpleLocalIntegration } from '../../core/index.js';
+import * as plugins from '../../plugins.js';
+import { BaseIntegration } from '../../core/classes.baseintegration.js';
+import { NoSqlConfigStore } from '../../core/classes.configstore.js';
+import { WebostvClient } from './webostv.classes.client.js';
 import { WebostvConfigFlow } from './webostv.classes.configflow.js';
 import { createWebostvDiscoveryDescriptor } from './webostv.discovery.js';
-import { webostvDomain, webostvProfile } from './webostv.types.js';
-export class WebostvIntegration extends SimpleLocalIntegration {
-    domain = webostvDomain;
+import { WebostvMapper } from './webostv.mapper.js';
+import { webostvProfile } from './webostv.types.js';
+import { webostvKeys, webostvObject } from './webostv.validation.js';
+export class WebostvIntegration extends BaseIntegration {
+    options;
+    domain = 'webostv';
+    displayName = 'LG webOS TV';
+    status = 'control-runtime';
+    metadata = webostvProfile.metadata;
     discoveryDescriptor = createWebostvDiscoveryDescriptor();
     configFlow = new WebostvConfigFlow();
-    constructor() {
-        super(webostvProfile);
+    #runtimes = new Set();
+    #pending = new Set();
+    #destroyed = false;
+    #destroy;
+    constructor(options) {
+        super();
+        this.options = options;
+    }
+    async setup(configArg, contextArg) {
+        if (this.#destroyed)
+            throw new Error('webOS integration is destroyed.');
+        if (contextArg.configStore !== undefined && !(contextArg.configStore instanceof NoSqlConfigStore))
+            throw new TypeError('webOS runtime context requires an encrypted NoSqlConfigStore.');
+        const client = new WebostvClient(configArg, contextArg.configStore ?? this.options, contextArg.abortSignal);
+        this.#pending.add(client);
+        try {
+            const snapshot = await client.getSnapshot(contextArg.abortSignal);
+            if (this.#destroyed)
+                throw new Error('webOS integration was destroyed during setup.');
+            const runtime = new WebostvRuntime(client, snapshot, () => this.#runtimes.delete(runtime));
+            this.#runtimes.add(runtime);
+            return runtime;
+        }
+        catch (errorArg) {
+            await client.destroy();
+            throw errorArg;
+        }
+        finally {
+            this.#pending.delete(client);
+        }
+    }
+    destroy() {
+        if (this.#destroy)
+            return this.#destroy;
+        this.#destroyed = true;
+        this.#destroy = Promise.all([...this.#runtimes].map((runtimeArg) => runtimeArg.destroy()).concat([...this.#pending].map((clientArg) => clientArg.destroy()))).then(() => undefined);
+        return this.#destroy;
     }
 }
 export class HomeAssistantWebostvIntegration extends WebostvIntegration {
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2Vib3N0di5jbGFzc2VzLmludGVncmF0aW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vdHMvaW50ZWdyYXRpb25zL3dlYm9zdHYvd2Vib3N0di5jbGFzc2VzLmludGVncmF0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBQzdELE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQ3BFLE9BQU8sRUFBRSxnQ0FBZ0MsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBRTFFLE9BQU8sRUFBRSxhQUFhLEVBQUUsY0FBYyxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFFbkUsTUFBTSxPQUFPLGtCQUFtQixTQUFRLHNCQUFzQztJQUM1RCxNQUFNLEdBQUcsYUFBYSxDQUFDO0lBQ3ZCLG1CQUFtQixHQUFHLGdDQUFnQyxFQUFFLENBQUM7SUFDekQsVUFBVSxHQUFHLElBQUksaUJBQWlCLEVBQUUsQ0FBQztJQUVyRDtRQUNFLEtBQUssQ0FBQyxjQUFjLENBQUMsQ0FBQztJQUN4QixDQUFDO0NBQ0Y7QUFFRCxNQUFNLE9BQU8sK0JBQWdDLFNBQVEsa0JBQWtCO0NBQUcifQ==
+class WebostvRuntime {
+    client;
+    identity;
+    onDestroyed;
+    domain = 'webostv';
+    constructor(client, identity, onDestroyed) {
+        this.client = client;
+        this.identity = identity;
+        this.onDestroyed = onDestroyed;
+    }
+    isHealthy() { return this.client.isHealthy(); }
+    async devices(signalArg) { return WebostvMapper.toDevices(await this.client.getSnapshot(signalArg)); }
+    async entities() { return WebostvMapper.toEntities(await this.client.getSnapshot()); }
+    async subscribe(handlerArg, signalArg) {
+        return this.client.subscribe((eventArg) => {
+            const base = { integrationDomain: this.domain, deviceId: WebostvMapper.deviceId(this.identity), timestamp: Date.now() };
+            if (eventArg.type === 'state')
+                handlerArg({ ...base, type: 'state_changed', entityId: `${base.deviceId}:media_player`, data: { entity: WebostvMapper.toEntities(eventArg.snapshot)[0] } });
+            else if (eventArg.type === 'availability')
+                handlerArg({ ...base, type: 'availability_changed', data: { available: eventArg.available } });
+            else
+                handlerArg({ ...base, type: 'error', data: { message: eventArg.error.message } });
+        }, signalArg);
+    }
+    async callService(requestArg) {
+        try {
+            const request = webostvObject(requestArg, 'service request');
+            webostvKeys(request, ['domain', 'service', 'target', 'data']);
+            if (request.domain !== 'webostv' && request.domain !== 'media_player')
+                throw new Error('webOS service domain is unsupported.');
+            const target = webostvObject(request.target, 'service target');
+            webostvKeys(target, ['deviceId', 'entityId']);
+            const deviceId = WebostvMapper.deviceId(this.identity);
+            if ((target.deviceId !== undefined && target.deviceId !== deviceId) || (target.entityId !== undefined && target.entityId !== `${deviceId}:media_player`) || (target.deviceId === undefined && target.entityId === undefined))
+                throw new Error('webOS services require an exact owned device or media-player entity target.');
+            const data = request.data === undefined ? {} : webostvObject(request.data, 'service data');
+            const service = request.service;
+            if (typeof service !== 'string')
+                throw new Error('webOS service must be a string.');
+            if (['status', 'snapshot'].includes(service)) {
+                webostvKeys(data, []);
+                return { success: true, data: await this.client.getSnapshot() };
+            }
+            let argument;
+            if (service === 'volume_set') {
+                webostvKeys(data, ['volume']);
+                argument = data.volume;
+            }
+            else if (service === 'volume_mute') {
+                webostvKeys(data, ['mute']);
+                argument = data.mute;
+            }
+            else if (service === 'select_source') {
+                webostvKeys(data, ['inputId']);
+                argument = data.inputId;
+            }
+            else
+                webostvKeys(data, []);
+            await this.client.execute(service, argument);
+            return { success: true, data: { acknowledgement: 'tv-response', state: 'observe-subscriptions' } };
+        }
+        catch (errorArg) {
+            return { success: false, error: errorArg instanceof Error ? errorArg.message : 'webOS operation failed.' };
+        }
+    }
+    async writeFeature(requestArg, signalArg) {
+        try {
+            const request = webostvObject(requestArg, 'feature write');
+            webostvKeys(request, ['device', 'feature', 'value']);
+            const device = webostvObject(request.device, 'feature device');
+            const feature = webostvObject(request.feature, 'feature');
+            if (device.id !== WebostvMapper.deviceId(this.identity) || device.integrationDomain !== this.domain)
+                throw new Error('webOS feature device is not owned by this runtime.');
+            if (feature.id === 'volume')
+                await this.client.execute('volume_set', request.value, signalArg);
+            else if (feature.id === 'muted')
+                await this.client.execute('volume_mute', request.value, signalArg);
+            else
+                throw new Error('webOS feature is not writable.');
+            return { success: true, data: { acknowledgement: 'tv-response', state: 'observe-subscriptions' } };
+        }
+        catch (errorArg) {
+            return { success: false, error: errorArg instanceof Error ? errorArg.message : 'webOS feature write failed.' };
+        }
+    }
+    async destroy() { await this.client.destroy(); this.onDestroyed(); }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"webostv.classes.integration.js","sourceRoot":"","sources":["../../../ts/integrations/webostv/webostv.classes.integration.ts"],"names":[],"mappings":"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"}

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

@@ -1 +1,2 @@
-export declare const createWebostvDiscoveryDescriptor: () => import("../../core/classes.discoverydescriptor.js").DiscoveryDescriptor;
+import { DiscoveryDescriptor } from '../../core/classes.discoverydescriptor.js';
+export declare const createWebostvDiscoveryDescriptor: () => DiscoveryDescriptor;

package/dist_ts/integrations/webostv/webostv.discovery.js

@@ -1,4 +1,26 @@
-import { createSimpleLocalDiscoveryDescriptor } from '../../core/index.js';
-import { webostvProfile } from './webostv.types.js';
-export const createWebostvDiscoveryDescriptor = () => createSimpleLocalDiscoveryDescriptor(webostvProfile);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2Vib3N0di5kaXNjb3ZlcnkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9pbnRlZ3JhdGlvbnMvd2Vib3N0di93ZWJvc3R2LmRpc2NvdmVyeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsb0NBQW9DLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUMzRSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFFcEQsTUFBTSxDQUFDLE1BQU0sZ0NBQWdDLEdBQUcsR0FBRyxFQUFFLENBQUMsb0NBQW9DLENBQUMsY0FBYyxDQUFDLENBQUMifQ==
+import { DiscoveryDescriptor } from '../../core/classes.discoverydescriptor.js';
+import { webostvKeys, webostvObject, webostvString } from './webostv.validation.js';
+const admit = (valueArg) => {
+    try {
+        const value = webostvObject(valueArg, 'webOS candidate');
+        webostvKeys(value, ['source', 'integrationDomain', 'id', 'host', 'port', 'name', 'manufacturer', 'model', 'serialNumber', 'metadata']);
+        if (value.source !== 'manual' || value.integrationDomain !== 'webostv')
+            throw new Error('Use an explicitly verified manual webOS candidate.');
+        const metadata = webostvObject(value.metadata, 'webOS candidate metadata');
+        webostvKeys(metadata, ['endpoint', 'expectedDeviceUUID']);
+        const endpoint = new URL(webostvString(metadata.endpoint, 'endpoint', 2048));
+        if (!['ws:', 'wss:'].includes(endpoint.protocol) || endpoint.username || endpoint.password || endpoint.pathname !== '/' || endpoint.search || endpoint.hash)
+            throw new Error('Invalid webOS endpoint origin.');
+        const uuid = webostvString(metadata.expectedDeviceUUID, 'expectedDeviceUUID');
+        const candidate = { source: 'manual', integrationDomain: 'webostv', host: endpoint.hostname, port: Number(endpoint.port || (endpoint.protocol === 'wss:' ? 443 : 80)), id: uuid,
+            name: value.name === undefined ? 'LG webOS TV' : webostvString(value.name, 'TV name'), manufacturer: 'LG', model: 'webOS TV', metadata: { endpoint: endpoint.href, expectedDeviceUUID: uuid } };
+        return { matched: true, confidence: 'high', reason: 'Explicit webOS endpoint and expected identity supplied; native registration verifies the TV.', candidate, normalizedDeviceId: uuid };
+    }
+    catch {
+        return { matched: false, confidence: 'low', reason: 'webOS requires a manual endpoint and independently verified expectedDeviceUUID.' };
+    }
+};
+export const createWebostvDiscoveryDescriptor = () => new DiscoveryDescriptor({ integrationDomain: 'webostv', displayName: 'LG webOS TV' })
+    .addMatcher({ id: 'webostv-manual-match', source: 'manual', matches: async (valueArg) => admit(valueArg) })
+    .addValidator({ id: 'webostv-identity-validate', validate: async (candidateArg) => admit(candidateArg) });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,10 +1,8 @@
-import type * as shxInterfaces from '@smarthome.exchange/interfaces';
-import { type IIntegrationEntity, type ISimpleLocalSnapshot, type ISimpleLocalSnapshotOptions, type TSimpleLocalRawData } from '../../core/index.js';
-import type { IWebostvConfig } from './webostv.types.js';
+import * as plugins from '../../plugins.js';
+import type { IIntegrationEntity } from '../../core/types.js';
+import type { IWebostvSnapshot } from './webostv.types.js';
 export declare class WebostvMapper {
-    static toSnapshot(optionsArg: Omit<ISimpleLocalSnapshotOptions<IWebostvConfig>, 'profile'>): ISimpleLocalSnapshot;
-    static toSnapshotFromRaw(configArg: IWebostvConfig, rawDataArg: TSimpleLocalRawData): ISimpleLocalSnapshot;
-    static toDevices(snapshotArg: ISimpleLocalSnapshot): shxInterfaces.data.IDeviceDefinition[];
-    static toEntities(snapshotArg: ISimpleLocalSnapshot): IIntegrationEntity[];
-    static slug(valueArg: unknown): string;
+    static deviceId(snapshotArg: Pick<IWebostvSnapshot, 'homeId' | 'deviceUUID'>): string;
+    static toDevices(snapshotArg: IWebostvSnapshot): plugins.shxInterfaces.data.IDeviceDefinition[];
+    static toEntities(snapshotArg: IWebostvSnapshot): IIntegrationEntity[];
 }

package/dist_ts/integrations/webostv/webostv.mapper.js

@@ -1,20 +1,31 @@
-import { SimpleLocalMapper } from '../../core/index.js';
-import { webostvProfile } from './webostv.types.js';
+import * as plugins from '../../plugins.js';
 export class WebostvMapper {
-    static toSnapshot(optionsArg) {
-        return SimpleLocalMapper.toSnapshot({ ...optionsArg, profile: webostvProfile });
-    }
-    static toSnapshotFromRaw(configArg, rawDataArg) {
-        return SimpleLocalMapper.toSnapshot({ profile: webostvProfile, config: configArg, rawData: rawDataArg, online: true, source: 'manual' });
+    static deviceId(snapshotArg) {
+        return `webostv:${encodeURIComponent(snapshotArg.homeId)}:${encodeURIComponent(snapshotArg.deviceUUID)}`;
     }
     static toDevices(snapshotArg) {
-        return SimpleLocalMapper.toDevices(webostvProfile, snapshotArg);
+        const states = [
+            ['power', snapshotArg.powerState], ['volume', snapshotArg.volume], ['muted', snapshotArg.muted], ['current_app', snapshotArg.currentAppId],
+        ];
+        return [{
+                id: this.deviceId(snapshotArg), integrationDomain: 'webostv', name: snapshotArg.name,
+                protocol: 'http', manufacturer: 'LG', model: 'webOS TV', online: snapshotArg.connected,
+                features: [
+                    { id: 'power', capability: 'media', name: 'Power state', readable: true, writable: false },
+                    { id: 'volume', capability: 'media', name: 'Volume', readable: true, writable: true, unit: '%' },
+                    { id: 'muted', capability: 'media', name: 'Muted', readable: true, writable: true },
+                    { id: 'current_app', capability: 'media', name: 'Foreground application', readable: true, writable: false },
+                ],
+                state: states.map(([featureId, value]) => ({ featureId, value, updatedAt: snapshotArg.observedAt })),
+                metadata: { homeId: snapshotArg.homeId, deviceUUID: snapshotArg.deviceUUID, transport: 'ssap-websocket', inputs: structuredClone(snapshotArg.inputs) },
+            }];
     }
     static toEntities(snapshotArg) {
-        return SimpleLocalMapper.toEntities(webostvProfile, snapshotArg);
-    }
-    static slug(valueArg) {
-        return SimpleLocalMapper.slug(valueArg);
+        const deviceId = this.deviceId(snapshotArg);
+        return [{ id: `${deviceId}:media_player`, uniqueId: `${deviceId}:media_player`, integrationDomain: 'webostv', deviceId,
+                platform: 'media_player', name: snapshotArg.name, state: snapshotArg.powerState, available: snapshotArg.connected,
+                attributes: { volume: snapshotArg.volume, muted: snapshotArg.muted, currentAppId: snapshotArg.currentAppId, inputs: structuredClone(snapshotArg.inputs), observedAt: snapshotArg.observedAt },
+            }];
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2Vib3N0di5tYXBwZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9pbnRlZ3JhdGlvbnMvd2Vib3N0di93ZWJvc3R2Lm1hcHBlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsaUJBQWlCLEVBQWtILE1BQU0scUJBQXFCLENBQUM7QUFFeEssT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBRXBELE1BQU0sT0FBTyxhQUFhO0lBQ2pCLE1BQU0sQ0FBQyxVQUFVLENBQUMsVUFBd0U7UUFDL0YsT0FBTyxpQkFBaUIsQ0FBQyxVQUFVLENBQUMsRUFBRSxHQUFHLFVBQVUsRUFBRSxPQUFPLEVBQUUsY0FBYyxFQUFFLENBQUMsQ0FBQztJQUNsRixDQUFDO0lBRU0sTUFBTSxDQUFDLGlCQUFpQixDQUFDLFNBQXlCLEVBQUUsVUFBK0I7UUFDeEYsT0FBTyxpQkFBaUIsQ0FBQyxVQUFVLENBQUMsRUFBRSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sRUFBRSxTQUFTLEVBQUUsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLEVBQUUsSUFBSSxFQUFFLE1BQU0sRUFBRSxRQUFRLEVBQUUsQ0FBQyxDQUFDO0lBQzNJLENBQUM7SUFFTSxNQUFNLENBQUMsU0FBUyxDQUFDLFdBQWlDO1FBQ3ZELE9BQU8saUJBQWlCLENBQUMsU0FBUyxDQUFDLGNBQWMsRUFBRSxXQUFXLENBQUMsQ0FBQztJQUNsRSxDQUFDO0lBRU0sTUFBTSxDQUFDLFVBQVUsQ0FBQyxXQUFpQztRQUN4RCxPQUFPLGlCQUFpQixDQUFDLFVBQVUsQ0FBQyxjQUFjLEVBQUUsV0FBVyxDQUFDLENBQUM7SUFDbkUsQ0FBQztJQUVNLE1BQU0sQ0FBQyxJQUFJLENBQUMsUUFBaUI7UUFDbEMsT0FBTyxpQkFBaUIsQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDLENBQUM7SUFDMUMsQ0FBQztDQUNGIn0=
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/integrations/webostv/webostv.types.d.ts

@@ -1,11 +1,67 @@
-import type { ISimpleLocalConfig, ISimpleLocalIntegrationProfile, ISimpleLocalSnapshot, TSimpleLocalRawData } from '../../core/index.js';
+import type * as plugins from '../../plugins.js';
+import type { IConfigEncryptionKeyProvider } from '../../core/classes.configstore.js';
 export declare const webostvDomain = "webostv";
 export declare const webostvDefaultName = "LG webOS TV";
-export type TWebostvRawData = TSimpleLocalRawData;
-export interface IWebostvSnapshot extends ISimpleLocalSnapshot {
+export interface IWebostvConfig {
+    homeId: string;
+    endpoint: string;
+    /** UUID reported by the verified TV's SSAP hello response. */
+    expectedDeviceUUID: string;
+    name?: string;
+    pairingMode: 'existing' | 'prompt';
+    /** Required acknowledgement for an explicitly selected cleartext local endpoint. */
+    allowUnencryptedConnection?: boolean;
+    certificateAuthority?: string;
+    requestTimeoutMs?: number;
+    pairingTimeoutMs?: number;
+    maxPendingRequests?: number;
 }
-export interface IWebostvConfig extends ISimpleLocalConfig {
+export interface IWebostvIntegrationOptions {
+    db: plugins.nosqldb.SmartdataDb;
+    keyProvider: IConfigEncryptionKeyProvider;
 }
 export interface IHomeAssistantWebostvConfig extends IWebostvConfig {
 }
-export declare const webostvProfile: ISimpleLocalIntegrationProfile;
+export interface IWebostvInput {
+    id: string;
+    label: string;
+    appId: string;
+    connected: boolean;
+}
+export interface IWebostvSnapshot {
+    homeId: string;
+    deviceUUID: string;
+    name: string;
+    connected: boolean;
+    powerState: string;
+    volume: number;
+    muted: boolean;
+    currentAppId: string;
+    inputs: IWebostvInput[];
+    observedAt: string;
+}
+export type TWebostvRawData = IWebostvSnapshot;
+export type TWebostvClientEvent = {
+    type: 'state';
+    snapshot: IWebostvSnapshot;
+} | {
+    type: 'availability';
+    available: boolean;
+} | {
+    type: 'error';
+    error: Error;
+};
+export type TWebostvCommand = 'turn_on' | 'turn_off' | 'volume_set' | 'volume_up' | 'volume_down' | 'volume_mute' | 'select_source' | 'media_play' | 'media_pause' | 'media_stop';
+export declare const webostvProfile: {
+    readonly domain: "webostv";
+    readonly displayName: "LG webOS TV";
+    readonly status: 'control-runtime';
+    readonly metadata: {
+        readonly source: 'home-assistant/core';
+        readonly upstreamDomain: "webostv";
+        readonly localApi: {
+            readonly implemented: readonly ['verified SSAP registration', 'encrypted durable pairing keys', 'authoritative state subscriptions'];
+            readonly explicitUnsupported: readonly ['fixture or injected-client production configs', 'deep standby wake-on-LAN', 'next/previous media track', 'automatic command replay'];
+        };
+    };
+};

package/dist_ts/integrations/webostv/webostv.types.js

@@ -1,98 +1,7 @@
-export const webostvDomain = "webostv";
-export const webostvDefaultName = "LG webOS TV";
+export const webostvDomain = 'webostv';
+export const webostvDefaultName = 'LG webOS TV';
 export const webostvProfile = {
-    domain: "webostv",
-    displayName: "LG webOS TV",
-    manufacturer: "LG",
-    model: "webOS TV",
-    defaultName: "LG webOS TV",
-    defaultPort: 3000,
-    defaultProtocol: "websocket",
-    status: "control-runtime",
-    platforms: [
-        "media_player",
-        "sensor"
-    ],
-    serviceDomains: [
-        "media_player"
-    ],
-    controlServices: [
-        "turn_on",
-        "turn_off",
-        "volume_up",
-        "volume_down",
-        "volume_mute",
-        "select_source",
-        "media_play",
-        "media_pause",
-        "media_stop",
-        "media_next_track",
-        "media_previous_track"
-    ],
-    discoverySources: [
-        "manual",
-        "mdns",
-        "ssdp",
-        "http",
-        "custom"
-    ],
-    discoveryKeywords: [
-        "lg",
-        "webos",
-        "tv"
-    ],
-    metadata: {
-        source: "home-assistant/core",
-        upstreamPath: "homeassistant/components/webostv",
-        upstreamDomain: "webostv",
-        integrationType: "device",
-        iotClass: "local_push",
-        qualityScale: "platinum",
-        requirements: [
-            "aiowebostv==0.7.5"
-        ],
-        dependencies: [],
-        afterDependencies: [],
-        codeowners: [
-            "@thecode"
-        ],
-        configFlow: true,
-        runtime: {
-            type: "control-runtime",
-            services: [
-                "snapshot",
-                "status",
-                "refresh",
-                "turn_on",
-                "turn_off",
-                "volume_up",
-                "volume_down",
-                "volume_mute",
-                "select_source",
-                "media_play",
-                "media_pause",
-                "media_stop",
-                "media_next_track",
-                "media_previous_track"
-            ],
-            platforms: [
-                "media_player",
-                "sensor"
-            ],
-            controls: true
-        },
-        localApi: {
-            implemented: [
-                "manual local endpoint setup",
-                "snapshot, raw data, snapshotProvider, and injected native client operation",
-                "generic HTTP/TCP local transport when config.path, config.transport, or documented defaults are supplied"
-            ],
-            explicitUnsupported: [
-                "claiming live command success without injected client.execute or commandExecutor",
-                "cloud account flows and remote API polling",
-                "device-specific protocol features not represented by snapshot/rawData/client/executor inputs"
-            ]
-        }
-    }
+    domain: webostvDomain, displayName: webostvDefaultName, status: 'control-runtime',
+    metadata: { source: 'home-assistant/core', upstreamDomain: webostvDomain, localApi: { implemented: ['verified SSAP registration', 'encrypted durable pairing keys', 'authoritative state subscriptions'], explicitUnsupported: ['fixture or injected-client production configs', 'deep standby wake-on-LAN', 'next/previous media track', 'automatic command replay'] } },
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2Vib3N0di50eXBlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3RzL2ludGVncmF0aW9ucy93ZWJvc3R2L3dlYm9zdHYudHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsTUFBTSxDQUFDLE1BQU0sYUFBYSxHQUFHLFNBQVMsQ0FBQztBQUN2QyxNQUFNLENBQUMsTUFBTSxrQkFBa0IsR0FBRyxhQUFhLENBQUM7QUFPaEQsTUFBTSxDQUFDLE1BQU0sY0FBYyxHQUFtQztJQUM1RCxNQUFNLEVBQUUsU0FBUztJQUNqQixXQUFXLEVBQUUsYUFBYTtJQUMxQixZQUFZLEVBQUUsSUFBSTtJQUNsQixLQUFLLEVBQUUsVUFBVTtJQUNqQixXQUFXLEVBQUUsYUFBYTtJQUMxQixXQUFXLEVBQUUsSUFBSTtJQUNqQixlQUFlLEVBQUUsV0FBVztJQUM1QixNQUFNLEVBQUUsaUJBQWlCO0lBQ3pCLFNBQVMsRUFBRTtRQUNULGNBQWM7UUFDZCxRQUFRO0tBQ1Q7SUFDRCxjQUFjLEVBQUU7UUFDZCxjQUFjO0tBQ2Y7SUFDRCxlQUFlLEVBQUU7UUFDZixTQUFTO1FBQ1QsVUFBVTtRQUNWLFdBQVc7UUFDWCxhQUFhO1FBQ2IsYUFBYTtRQUNiLGVBQWU7UUFDZixZQUFZO1FBQ1osYUFBYTtRQUNiLFlBQVk7UUFDWixrQkFBa0I7UUFDbEIsc0JBQXNCO0tBQ3ZCO0lBQ0QsZ0JBQWdCLEVBQUU7UUFDaEIsUUFBUTtRQUNSLE1BQU07UUFDTixNQUFNO1FBQ04sTUFBTTtRQUNOLFFBQVE7S0FDVDtJQUNELGlCQUFpQixFQUFFO1FBQ2pCLElBQUk7UUFDSixPQUFPO1FBQ1AsSUFBSTtLQUNMO0lBQ0QsUUFBUSxFQUFFO1FBQ1IsTUFBTSxFQUFFLHFCQUFxQjtRQUM3QixZQUFZLEVBQUUsa0NBQWtDO1FBQ2hELGNBQWMsRUFBRSxTQUFTO1FBQ3pCLGVBQWUsRUFBRSxRQUFRO1FBQ3pCLFFBQVEsRUFBRSxZQUFZO1FBQ3RCLFlBQVksRUFBRSxVQUFVO1FBQ3hCLFlBQVksRUFBRTtZQUNaLG1CQUFtQjtTQUNwQjtRQUNELFlBQVksRUFBRSxFQUFFO1FBQ2hCLGlCQUFpQixFQUFFLEVBQUU7UUFDckIsVUFBVSxFQUFFO1lBQ1YsVUFBVTtTQUNYO1FBQ0QsVUFBVSxFQUFFLElBQUk7UUFDaEIsT0FBTyxFQUFFO1lBQ1AsSUFBSSxFQUFFLGlCQUFpQjtZQUN2QixRQUFRLEVBQUU7Z0JBQ1IsVUFBVTtnQkFDVixRQUFRO2dCQUNSLFNBQVM7Z0JBQ1QsU0FBUztnQkFDVCxVQUFVO2dCQUNWLFdBQVc7Z0JBQ1gsYUFBYTtnQkFDYixhQUFhO2dCQUNiLGVBQWU7Z0JBQ2YsWUFBWTtnQkFDWixhQUFhO2dCQUNiLFlBQVk7Z0JBQ1osa0JBQWtCO2dCQUNsQixzQkFBc0I7YUFDdkI7WUFDRCxTQUFTLEVBQUU7Z0JBQ1QsY0FBYztnQkFDZCxRQUFRO2FBQ1Q7WUFDRCxRQUFRLEVBQUUsSUFBSTtTQUNmO1FBQ0QsUUFBUSxFQUFFO1lBQ1IsV0FBVyxFQUFFO2dCQUNYLDZCQUE2QjtnQkFDN0IsNEVBQTRFO2dCQUM1RSwwR0FBMEc7YUFDM0c7WUFDRCxtQkFBbUIsRUFBRTtnQkFDbkIsa0ZBQWtGO2dCQUNsRiw0Q0FBNEM7Z0JBQzVDLDhGQUE4RjthQUMvRjtTQUNGO0tBQ0Y7Q0FDRixDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2Vib3N0di50eXBlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3RzL2ludGVncmF0aW9ucy93ZWJvc3R2L3dlYm9zdHYudHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBR0EsTUFBTSxDQUFDLE1BQU0sYUFBYSxHQUFHLFNBQVMsQ0FBQztBQUN2QyxNQUFNLENBQUMsTUFBTSxrQkFBa0IsR0FBRyxhQUFhLENBQUM7QUEyQ2hELE1BQU0sQ0FBQyxNQUFNLGNBQWMsR0FBRztJQUM1QixNQUFNLEVBQUUsYUFBYSxFQUFFLFdBQVcsRUFBRSxrQkFBa0IsRUFBRSxNQUFNLEVBQUUsaUJBQWlCO0lBQ2pGLFFBQVEsRUFBRSxFQUFFLE1BQU0sRUFBRSxxQkFBcUIsRUFBRSxjQUFjLEVBQUUsYUFBYSxFQUFFLFFBQVEsRUFBRSxFQUFFLFdBQVcsRUFBRSxDQUFDLDRCQUE0QixFQUFFLGdDQUFnQyxFQUFFLG1DQUFtQyxDQUFDLEVBQUUsbUJBQW1CLEVBQUUsQ0FBQywrQ0FBK0MsRUFBRSwwQkFBMEIsRUFBRSwyQkFBMkIsRUFBRSwwQkFBMEIsQ0FBQyxFQUFFLEVBQUU7Q0FDalcsQ0FBQyJ9

package/dist_ts/integrations/webostv/webostv.validation.d.ts

@@ -0,0 +1,6 @@
+import type { IWebostvConfig } from './webostv.types.js';
+export declare const webostvObject: (valueArg: unknown, nameArg: string) => Record<string, unknown>;
+export declare const webostvKeys: (valueArg: Record<string, unknown>, keysArg: readonly string[]) => void;
+export declare const webostvString: (valueArg: unknown, nameArg: string, maximumArg?: number) => string;
+export declare const webostvInteger: (valueArg: unknown, nameArg: string, minimumArg: number, maximumArg: number) => number;
+export declare const normalizeWebostvConfig: (valueArg: IWebostvConfig) => Readonly<IWebostvConfig>;

package/dist_ts/integrations/webostv/webostv.validation.js

@@ -0,0 +1,54 @@
+export const webostvObject = (valueArg, nameArg) => {
+    if (!valueArg || typeof valueArg !== 'object' || Array.isArray(valueArg) || ![Object.prototype, null].includes(Object.getPrototypeOf(valueArg)))
+        throw new TypeError(`${nameArg} must be a plain object.`);
+    const result = {};
+    for (const key of Reflect.ownKeys(valueArg)) {
+        const descriptor = Object.getOwnPropertyDescriptor(valueArg, key);
+        if (typeof key !== 'string' || !descriptor || !('value' in descriptor) || !descriptor.enumerable)
+            throw new TypeError(`${nameArg} must contain only enumerable data fields.`);
+        Object.defineProperty(result, key, { value: descriptor.value, enumerable: true, writable: true, configurable: true });
+    }
+    return result;
+};
+export const webostvKeys = (valueArg, keysArg) => {
+    if (Object.keys(valueArg).some((keyArg) => !keysArg.includes(keyArg)))
+        throw new TypeError('webOS arguments contain unsupported fields.');
+};
+export const webostvString = (valueArg, nameArg, maximumArg = 256) => {
+    if (typeof valueArg !== 'string' || !valueArg.length || valueArg.length > maximumArg || /[\p{Cc}\p{Cs}]/u.test(valueArg))
+        throw new TypeError(`${nameArg} must be a nonempty bounded string without control characters.`);
+    return valueArg;
+};
+export const webostvInteger = (valueArg, nameArg, minimumArg, maximumArg) => {
+    if (typeof valueArg !== 'number' || !Number.isSafeInteger(valueArg) || valueArg < minimumArg || valueArg > maximumArg)
+        throw new TypeError(`${nameArg} must be an integer from ${minimumArg} through ${maximumArg}.`);
+    return valueArg;
+};
+export const normalizeWebostvConfig = (valueArg) => {
+    const value = webostvObject(valueArg, 'webOS config');
+    webostvKeys(value, ['homeId', 'endpoint', 'expectedDeviceUUID', 'name', 'pairingMode', 'allowUnencryptedConnection', 'certificateAuthority', 'requestTimeoutMs', 'pairingTimeoutMs', 'maxPendingRequests']);
+    const endpoint = new URL(webostvString(value.endpoint, 'endpoint', 2048));
+    if (!['ws:', 'wss:'].includes(endpoint.protocol) || endpoint.username || endpoint.password || endpoint.pathname !== '/' || endpoint.search || endpoint.hash || !endpoint.hostname)
+        throw new TypeError('webOS endpoint must be an explicit ws/wss origin without credentials, path, query or fragment.');
+    if (value.allowUnencryptedConnection !== undefined && typeof value.allowUnencryptedConnection !== 'boolean')
+        throw new TypeError('allowUnencryptedConnection must be boolean.');
+    if (endpoint.protocol === 'ws:' && value.allowUnencryptedConnection !== true)
+        throw new TypeError('A cleartext webOS endpoint requires allowUnencryptedConnection: true.');
+    if (endpoint.protocol === 'ws:' && value.certificateAuthority !== undefined)
+        throw new TypeError('A certificate authority requires wss.');
+    if (value.pairingMode !== 'existing' && value.pairingMode !== 'prompt')
+        throw new TypeError('webOS pairingMode must be existing or prompt.');
+    if (value.certificateAuthority !== undefined && (typeof value.certificateAuthority !== 'string' || value.certificateAuthority.length > 65536 || !value.certificateAuthority.includes('-----BEGIN CERTIFICATE-----')))
+        throw new TypeError('certificateAuthority must be a bounded PEM certificate chain.');
+    return Object.freeze({
+        homeId: webostvString(value.homeId, 'homeId'), endpoint: endpoint.href,
+        expectedDeviceUUID: webostvString(value.expectedDeviceUUID, 'expectedDeviceUUID'),
+        name: value.name === undefined ? 'LG webOS TV' : webostvString(value.name, 'name'),
+        pairingMode: value.pairingMode, allowUnencryptedConnection: value.allowUnencryptedConnection,
+        certificateAuthority: value.certificateAuthority,
+        requestTimeoutMs: webostvInteger(value.requestTimeoutMs ?? 5000, 'requestTimeoutMs', 20, 60000),
+        pairingTimeoutMs: webostvInteger(value.pairingTimeoutMs ?? 30000, 'pairingTimeoutMs', 20, 120000),
+        maxPendingRequests: webostvInteger(value.maxPendingRequests ?? 32, 'maxPendingRequests', 1, 128),
+    });
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2Vib3N0di52YWxpZGF0aW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vdHMvaW50ZWdyYXRpb25zL3dlYm9zdHYvd2Vib3N0di52YWxpZGF0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE1BQU0sQ0FBQyxNQUFNLGFBQWEsR0FBRyxDQUFDLFFBQWlCLEVBQUUsT0FBZSxFQUEyQixFQUFFO0lBQzNGLElBQUksQ0FBQyxRQUFRLElBQUksT0FBTyxRQUFRLEtBQUssUUFBUSxJQUFJLEtBQUssQ0FBQyxPQUFPLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxDQUFDLE1BQU0sQ0FBQyxTQUFTLEVBQUUsSUFBSSxDQUFDLENBQUMsUUFBUSxDQUFDLE1BQU0sQ0FBQyxjQUFjLENBQUMsUUFBUSxDQUFDLENBQUM7UUFBRSxNQUFNLElBQUksU0FBUyxDQUFDLEdBQUcsT0FBTywwQkFBMEIsQ0FBQyxDQUFDO0lBQzNNLE1BQU0sTUFBTSxHQUE0QixFQUFFLENBQUM7SUFDM0MsS0FBSyxNQUFNLEdBQUcsSUFBSSxPQUFPLENBQUMsT0FBTyxDQUFDLFFBQVEsQ0FBQyxFQUFFLENBQUM7UUFDNUMsTUFBTSxVQUFVLEdBQUcsTUFBTSxDQUFDLHdCQUF3QixDQUFDLFFBQVEsRUFBRSxHQUFHLENBQUMsQ0FBQztRQUNsRSxJQUFJLE9BQU8sR0FBRyxLQUFLLFFBQVEsSUFBSSxDQUFDLFVBQVUsSUFBSSxDQUFDLENBQUMsT0FBTyxJQUFJLFVBQVUsQ0FBQyxJQUFJLENBQUMsVUFBVSxDQUFDLFVBQVU7WUFBRSxNQUFNLElBQUksU0FBUyxDQUFDLEdBQUcsT0FBTyw0Q0FBNEMsQ0FBQyxDQUFDO1FBQzlLLE1BQU0sQ0FBQyxjQUFjLENBQUMsTUFBTSxFQUFFLEdBQUcsRUFBRSxFQUFFLEtBQUssRUFBRSxVQUFVLENBQUMsS0FBSyxFQUFFLFVBQVUsRUFBRSxJQUFJLEVBQUUsUUFBUSxFQUFFLElBQUksRUFBRSxZQUFZLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQztJQUN4SCxDQUFDO0lBQ0QsT0FBTyxNQUFNLENBQUM7QUFDaEIsQ0FBQyxDQUFDO0FBRUYsTUFBTSxDQUFDLE1BQU0sV0FBVyxHQUFHLENBQUMsUUFBaUMsRUFBRSxPQUEwQixFQUFRLEVBQUU7SUFDakcsSUFBSSxNQUFNLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDLE1BQU0sRUFBRSxFQUFFLENBQUMsQ0FBQyxPQUFPLENBQUMsUUFBUSxDQUFDLE1BQU0sQ0FBQyxDQUFDO1FBQUUsTUFBTSxJQUFJLFNBQVMsQ0FBQyw2Q0FBNkMsQ0FBQyxDQUFDO0FBQzVJLENBQUMsQ0FBQztBQUVGLE1BQU0sQ0FBQyxNQUFNLGFBQWEsR0FBRyxDQUFDLFFBQWlCLEVBQUUsT0FBZSxFQUFFLFVBQVUsR0FBRyxHQUFHLEVBQVUsRUFBRTtJQUM1RixJQUFJLE9BQU8sUUFBUSxLQUFLLFFBQVEsSUFBSSxDQUFDLFFBQVEsQ0FBQyxNQUFNLElBQUksUUFBUSxDQUFDLE1BQU0sR0FBRyxVQUFVLElBQUksaUJBQWlCLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQztRQUFFLE1BQU0sSUFBSSxTQUFTLENBQUMsR0FBRyxPQUFPLGdFQUFnRSxDQUFDLENBQUM7SUFDMU4sT0FBTyxRQUFRLENBQUM7QUFDbEIsQ0FBQyxDQUFDO0FBRUYsTUFBTSxDQUFDLE1BQU0sY0FBYyxHQUFHLENBQUMsUUFBaUIsRUFBRSxPQUFlLEVBQUUsVUFBa0IsRUFBRSxVQUFrQixFQUFVLEVBQUU7SUFDbkgsSUFBSSxPQUFPLFFBQVEsS0FBSyxRQUFRLElBQUksQ0FBQyxNQUFNLENBQUMsYUFBYSxDQUFDLFFBQVEsQ0FBQyxJQUFJLFFBQVEsR0FBRyxVQUFVLElBQUksUUFBUSxHQUFHLFVBQVU7UUFBRSxNQUFNLElBQUksU0FBUyxDQUFDLEdBQUcsT0FBTyw0QkFBNEIsVUFBVSxZQUFZLFVBQVUsR0FBRyxDQUFDLENBQUM7SUFDdE4sT0FBTyxRQUFRLENBQUM7QUFDbEIsQ0FBQyxDQUFDO0FBRUYsTUFBTSxDQUFDLE1BQU0sc0JBQXNCLEdBQUcsQ0FBQyxRQUF3QixFQUE0QixFQUFFO0lBQzNGLE1BQU0sS0FBSyxHQUFHLGFBQWEsQ0FBQyxRQUFRLEVBQUUsY0FBYyxDQUFDLENBQUM7SUFDdEQsV0FBVyxDQUFDLEtBQUssRUFBRSxDQUFDLFFBQVEsRUFBRSxVQUFVLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSxFQUFFLGFBQWEsRUFBRSw0QkFBNEIsRUFBRSxzQkFBc0IsRUFBRSxrQkFBa0IsRUFBRSxrQkFBa0IsRUFBRSxvQkFBb0IsQ0FBQyxDQUFDLENBQUM7SUFDNU0sTUFBTSxRQUFRLEdBQUcsSUFBSSxHQUFHLENBQUMsYUFBYSxDQUFDLEtBQUssQ0FBQyxRQUFRLEVBQUUsVUFBVSxFQUFFLElBQUksQ0FBQyxDQUFDLENBQUM7SUFDMUUsSUFBSSxDQUFDLENBQUMsS0FBSyxFQUFFLE1BQU0sQ0FBQyxDQUFDLFFBQVEsQ0FBQyxRQUFRLENBQUMsUUFBUSxDQUFDLElBQUksUUFBUSxDQUFDLFFBQVEsSUFBSSxRQUFRLENBQUMsUUFBUSxJQUFJLFFBQVEsQ0FBQyxRQUFRLEtBQUssR0FBRyxJQUFJLFFBQVEsQ0FBQyxNQUFNLElBQUksUUFBUSxDQUFDLElBQUksSUFBSSxDQUFDLFFBQVEsQ0FBQyxRQUFRO1FBQUUsTUFBTSxJQUFJLFNBQVMsQ0FBQyxnR0FBZ0csQ0FBQyxDQUFDO0lBQ3pTLElBQUksS0FBSyxDQUFDLDBCQUEwQixLQUFLLFNBQVMsSUFBSSxPQUFPLEtBQUssQ0FBQywwQkFBMEIsS0FBSyxTQUFTO1FBQUUsTUFBTSxJQUFJLFNBQVMsQ0FBQyw2Q0FBNkMsQ0FBQyxDQUFDO0lBQ2hMLElBQUksUUFBUSxDQUFDLFFBQVEsS0FBSyxLQUFLLElBQUksS0FBSyxDQUFDLDBCQUEwQixLQUFLLElBQUk7UUFBRSxNQUFNLElBQUksU0FBUyxDQUFDLHVFQUF1RSxDQUFDLENBQUM7SUFDM0ssSUFBSSxRQUFRLENBQUMsUUFBUSxLQUFLLEtBQUssSUFBSSxLQUFLLENBQUMsb0JBQW9CLEtBQUssU0FBUztRQUFFLE1BQU0sSUFBSSxTQUFTLENBQUMsdUNBQXVDLENBQUMsQ0FBQztJQUMxSSxJQUFJLEtBQUssQ0FBQyxXQUFXLEtBQUssVUFBVSxJQUFJLEtBQUssQ0FBQyxXQUFXLEtBQUssUUFBUTtRQUFFLE1BQU0sSUFBSSxTQUFTLENBQUMsK0NBQStDLENBQUMsQ0FBQztJQUM3SSxJQUFJLEtBQUssQ0FBQyxvQkFBb0IsS0FBSyxTQUFTLElBQUksQ0FBQyxPQUFPLEtBQUssQ0FBQyxvQkFBb0IsS0FBSyxRQUFRLElBQUksS0FBSyxDQUFDLG9CQUFvQixDQUFDLE1BQU0sR0FBRyxLQUFLLElBQUksQ0FBQyxLQUFLLENBQUMsb0JBQW9CLENBQUMsUUFBUSxDQUFDLDZCQUE2QixDQUFDLENBQUM7UUFBRSxNQUFNLElBQUksU0FBUyxDQUFDLCtEQUErRCxDQUFDLENBQUM7SUFDM1MsT0FBTyxNQUFNLENBQUMsTUFBTSxDQUFDO1FBQ25CLE1BQU0sRUFBRSxhQUFhLENBQUMsS0FBSyxDQUFDLE1BQU0sRUFBRSxRQUFRLENBQUMsRUFBRSxRQUFRLEVBQUUsUUFBUSxDQUFDLElBQUk7UUFDdEUsa0JBQWtCLEVBQUUsYUFBYSxDQUFDLEtBQUssQ0FBQyxrQkFBa0IsRUFBRSxvQkFBb0IsQ0FBQztRQUNqRixJQUFJLEVBQUUsS0FBSyxDQUFDLElBQUksS0FBSyxTQUFTLENBQUMsQ0FBQyxDQUFDLGFBQWEsQ0FBQyxDQUFDLENBQUMsYUFBYSxDQUFDLEtBQUssQ0FBQyxJQUFJLEVBQUUsTUFBTSxDQUFDO1FBQ2xGLFdBQVcsRUFBRSxLQUFLLENBQUMsV0FBVyxFQUFFLDBCQUEwQixFQUFFLEtBQUssQ0FBQywwQkFBMEI7UUFDNUYsb0JBQW9CLEVBQUUsS0FBSyxDQUFDLG9CQUEwQztRQUN0RSxnQkFBZ0IsRUFBRSxjQUFjLENBQUMsS0FBSyxDQUFDLGdCQUFnQixJQUFJLElBQUksRUFBRSxrQkFBa0IsRUFBRSxFQUFFLEVBQUUsS0FBSyxDQUFDO1FBQy9GLGdCQUFnQixFQUFFLGNBQWMsQ0FBQyxLQUFLLENBQUMsZ0JBQWdCLElBQUksS0FBSyxFQUFFLGtCQUFrQixFQUFFLEVBQUUsRUFBRSxNQUFNLENBQUM7UUFDakcsa0JBQWtCLEVBQUUsY0FBYyxDQUFDLEtBQUssQ0FBQyxrQkFBa0IsSUFBSSxFQUFFLEVBQUUsb0JBQW9CLEVBQUUsQ0FBQyxFQUFFLEdBQUcsQ0FBQztLQUNqRyxDQUFDLENBQUM7QUFDTCxDQUFDLENBQUMifQ==

package/dist_ts/integrations/wiz/index.d.ts

@@ -4,3 +4,4 @@ export * from './wiz.classes.integration.js';
 export * from './wiz.discovery.js';
 export * from './wiz.mapper.js';
 export * from './wiz.types.js';
+export * from './wiz.validation.js';

package/dist_ts/integrations/wiz/index.js

@@ -4,4 +4,5 @@ export * from './wiz.classes.integration.js';
 export * from './wiz.discovery.js';
 export * from './wiz.mapper.js';
 export * from './wiz.types.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9pbnRlZ3JhdGlvbnMvd2l6L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyw2QkFBNkIsQ0FBQztBQUM1QyxjQUFjLDhCQUE4QixDQUFDO0FBQzdDLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLGdCQUFnQixDQUFDIn0=
+export * from './wiz.validation.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9pbnRlZ3JhdGlvbnMvd2l6L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyw2QkFBNkIsQ0FBQztBQUM1QyxjQUFjLDhCQUE4QixDQUFDO0FBQzdDLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMscUJBQXFCLENBQUMifQ==

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

@@ -1,31 +1,17 @@
-import type { IWizClientCommand, IWizCommandResult, IWizConfig, IWizEvent, IWizPilotPatch, IWizPilotState, IWizSnapshot, IWizUdpResponse } from './wiz.types.js';
-type TWizEventHandler = (eventArg: IWizEvent) => void;
+import type { IIntegrationSetupContext } from '../../core/types.js';
+import type { IWizConfig, IWizSnapshot, IWizWriteResult, TWizControl } from './wiz.types.js';
 export declare class WizClient {
-    private readonly config;
-    private readonly events;
-    private readonly eventHandlers;
-    constructor(config: IWizConfig);
-    getSnapshot(): Promise<IWizSnapshot>;
-    onEvent(handlerArg: TWizEventHandler): () => void;
-    getPilot(): Promise<IWizPilotState>;
-    setPilot(payloadArg: IWizPilotPatch): Promise<IWizUdpResponse<Record<string, unknown>>>;
-    getSystemConfig(): Promise<IWizUdpResponse<Record<string, unknown>>>;
-    sendCommand(commandArg: IWizClientCommand): Promise<IWizCommandResult>;
+    #private;
+    constructor(configArg: IWizConfig, contextArg: IIntegrationSetupContext);
+    get homeId(): string;
+    get pollIntervalMs(): number;
+    isHealthy(): boolean;
+    getSnapshot(signalArg?: AbortSignal): Promise<IWizSnapshot>;
+    write(controlArg: TWizControl, signalArg?: AbortSignal): Promise<IWizWriteResult>;
     destroy(): Promise<void>;
-    private liveDeviceInfo;
-    private staticDeviceInfo;
-    private sendUdp;
-    private emit;
-    private commandResult;
-    private isCommandResult;
-    private host;
-    private port;
-    private timeoutMs;
-    private unsupportedLiveControlMessage;
-    private textContainsSocket;
-    private textContains;
-    private stringValue;
-    private numberValue;
-    private record;
+    /** Explicitly retries retained cleanup; no protocol operation is replayed. */
+    retryCleanup(): Promise<void>;
+    private cleanup;
+    private signal;
+    private track;
 }
-export {};