@smarthome.exchange/integrations 0.2.0 → 2.0.0

package/ts/integrations/webostv/webostv.classes.integration.ts

@@ -1,17 +1,102 @@
-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 type { IDeviceFeatureWriteRequest, IIntegrationEntity, IIntegrationEvent, IIntegrationRuntime, IIntegrationSetupContext, IServiceCallRequest, IServiceCallResult } from '../../core/types.js';
+import { WebostvClient } from './webostv.classes.client.js';
 import { WebostvConfigFlow } from './webostv.classes.configflow.js';
 import { createWebostvDiscoveryDescriptor } from './webostv.discovery.js';
-import type { IWebostvConfig } from './webostv.types.js';
-import { webostvDomain, webostvProfile } from './webostv.types.js';
+import { WebostvMapper } from './webostv.mapper.js';
+import type { IWebostvConfig, IWebostvIntegrationOptions, IWebostvSnapshot, TWebostvCommand } from './webostv.types.js';
+import { webostvProfile } from './webostv.types.js';
+import { webostvKeys, webostvObject } from './webostv.validation.js';
 
-export class WebostvIntegration extends SimpleLocalIntegration<IWebostvConfig> {
-  public readonly domain = webostvDomain;
+export class WebostvIntegration extends BaseIntegration<IWebostvConfig> {
+  public readonly domain = 'webostv';
+  public readonly displayName = 'LG webOS TV';
+  public readonly status = 'control-runtime' as const;
+  public readonly metadata = webostvProfile.metadata;
   public readonly discoveryDescriptor = createWebostvDiscoveryDescriptor();
   public readonly configFlow = new WebostvConfigFlow();
+  readonly #runtimes = new Set<WebostvRuntime>();
+  readonly #pending = new Set<WebostvClient>();
+  #destroyed = false;
+  #destroy?: Promise<void>;
 
-  constructor() {
-    super(webostvProfile);
+  constructor(private readonly options?: IWebostvIntegrationOptions) { super(); }
+
+  public async setup(configArg: IWebostvConfig, contextArg: IIntegrationSetupContext): Promise<IIntegrationRuntime> {
+    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); }
+  }
+
+  public destroy(): Promise<void> {
+    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 {}
+
+class WebostvRuntime implements IIntegrationRuntime {
+  public readonly domain = 'webostv';
+  constructor(private readonly client: WebostvClient, private readonly identity: IWebostvSnapshot, private readonly onDestroyed: () => void) {}
+  public isHealthy(): boolean { return this.client.isHealthy(); }
+  public async devices(signalArg?: AbortSignal): Promise<plugins.shxInterfaces.data.IDeviceDefinition[]> { return WebostvMapper.toDevices(await this.client.getSnapshot(signalArg)); }
+  public async entities(): Promise<IIntegrationEntity[]> { return WebostvMapper.toEntities(await this.client.getSnapshot()); }
+  public async subscribe(handlerArg: (eventArg: IIntegrationEvent) => void, signalArg?: AbortSignal): Promise<() => Promise<void>> {
+    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);
+  }
+
+  public async callService(requestArg: IServiceCallRequest): Promise<IServiceCallResult> {
+    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: unknown;
+      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 as TWebostvCommand, 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.' }; }
+  }
+
+  public async writeFeature(requestArg: IDeviceFeatureWriteRequest, signalArg?: AbortSignal): Promise<IServiceCallResult> {
+    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.' }; }
+  }
+  public async destroy(): Promise<void> { await this.client.destroy(); this.onDestroyed(); }
+}

package/ts/integrations/webostv/webostv.discovery.ts

@@ -1,4 +1,23 @@
-import { createSimpleLocalDiscoveryDescriptor } from '../../core/index.js';
-import { webostvProfile } from './webostv.types.js';
+import { DiscoveryDescriptor } from '../../core/classes.discoverydescriptor.js';
+import type { IDiscoveryCandidate, IDiscoveryMatch } from '../../core/types.js';
+import { webostvKeys, webostvObject, webostvString } from './webostv.validation.js';
 
-export const createWebostvDiscoveryDescriptor = () => createSimpleLocalDiscoveryDescriptor(webostvProfile);
+const admit = (valueArg: unknown): IDiscoveryMatch => {
+  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: IDiscoveryCandidate = { 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 = (): DiscoveryDescriptor => new DiscoveryDescriptor({ integrationDomain: 'webostv', displayName: 'LG webOS TV' })
+  .addMatcher({ id: 'webostv-manual-match', source: 'manual', matches: async (valueArg: unknown) => admit(valueArg) })
+  .addValidator({ id: 'webostv-identity-validate', validate: async (candidateArg) => admit(candidateArg) });

package/ts/integrations/webostv/webostv.mapper.ts

@@ -1,26 +1,35 @@
-import type * as shxInterfaces from '@smarthome.exchange/interfaces';
-import { SimpleLocalMapper, type IIntegrationEntity, type ISimpleLocalSnapshot, type ISimpleLocalSnapshotOptions, type TSimpleLocalRawData } from '../../core/index.js';
-import type { IWebostvConfig } from './webostv.types.js';
-import { webostvProfile } 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 class WebostvMapper {
-  public static toSnapshot(optionsArg: Omit<ISimpleLocalSnapshotOptions<IWebostvConfig>, 'profile'>): ISimpleLocalSnapshot {
-    return SimpleLocalMapper.toSnapshot({ ...optionsArg, profile: webostvProfile });
+  public static deviceId(snapshotArg: Pick<IWebostvSnapshot, 'homeId' | 'deviceUUID'>): string {
+    return `webostv:${encodeURIComponent(snapshotArg.homeId)}:${encodeURIComponent(snapshotArg.deviceUUID)}`;
   }
 
-  public static toSnapshotFromRaw(configArg: IWebostvConfig, rawDataArg: TSimpleLocalRawData): ISimpleLocalSnapshot {
-    return SimpleLocalMapper.toSnapshot({ profile: webostvProfile, config: configArg, rawData: rawDataArg, online: true, source: 'manual' });
+  public static toDevices(snapshotArg: IWebostvSnapshot): plugins.shxInterfaces.data.IDeviceDefinition[] {
+    const states: Array<[string, plugins.shxInterfaces.data.TDeviceStateValue]> = [
+      ['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) },
+    }];
   }
 
-  public static toDevices(snapshotArg: ISimpleLocalSnapshot): shxInterfaces.data.IDeviceDefinition[] {
-    return SimpleLocalMapper.toDevices(webostvProfile, snapshotArg);
-  }
-
-  public static toEntities(snapshotArg: ISimpleLocalSnapshot): IIntegrationEntity[] {
-    return SimpleLocalMapper.toEntities(webostvProfile, snapshotArg);
-  }
-
-  public static slug(valueArg: unknown): string {
-    return SimpleLocalMapper.slug(valueArg);
+  public static toEntities(snapshotArg: IWebostvSnapshot): IIntegrationEntity[] {
+    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 },
+    }];
   }
 }

package/ts/integrations/webostv/webostv.types.ts

@@ -1,105 +1,51 @@
-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 const webostvDomain = "webostv";
-export const webostvDefaultName = "LG webOS TV";
+export const webostvDomain = 'webostv';
+export const webostvDefaultName = 'LG webOS TV';
+
+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 IWebostvIntegrationOptions {
+  db: plugins.nosqldb.SmartdataDb;
+  keyProvider: IConfigEncryptionKeyProvider;
+}
 
-export type TWebostvRawData = TSimpleLocalRawData;
-export interface IWebostvSnapshot extends ISimpleLocalSnapshot {}
-export interface IWebostvConfig extends ISimpleLocalConfig {}
 export interface IHomeAssistantWebostvConfig extends IWebostvConfig {}
+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 const webostvProfile: ISimpleLocalIntegrationProfile = {
-  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"
-      ]
-    }
-  }
-};
+export const webostvProfile = {
+  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'] } },
+} as const;

package/ts/integrations/webostv/webostv.validation.ts

@@ -0,0 +1,48 @@
+import type { IWebostvConfig } from './webostv.types.js';
+
+export const webostvObject = (valueArg: unknown, nameArg: string): Record<string, unknown> => {
+  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: Record<string, unknown> = {};
+  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: Record<string, unknown>, keysArg: readonly string[]): void => {
+  if (Object.keys(valueArg).some((keyArg) => !keysArg.includes(keyArg))) throw new TypeError('webOS arguments contain unsupported fields.');
+};
+
+export const webostvString = (valueArg: unknown, nameArg: string, maximumArg = 256): string => {
+  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: unknown, nameArg: string, minimumArg: number, maximumArg: number): number => {
+  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: IWebostvConfig): Readonly<IWebostvConfig> => {
+  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 as string | undefined,
+    requestTimeoutMs: webostvInteger(value.requestTimeoutMs ?? 5000, 'requestTimeoutMs', 20, 60000),
+    pairingTimeoutMs: webostvInteger(value.pairingTimeoutMs ?? 30000, 'pairingTimeoutMs', 20, 120000),
+    maxPendingRequests: webostvInteger(value.maxPendingRequests ?? 32, 'maxPendingRequests', 1, 128),
+  });
+};

package/ts/integrations/wiz/index.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';