@smarthome.exchange/integrations 1.0.0 → 3.0.0

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

@@ -1,3 +1,4 @@
+import type * as plugins from '../../plugins.js';
 export declare const daikinDomain = "daikin";
 export declare const daikinDisplayName = "Daikin AC";
 export declare const daikinDefaultHttpPort = 80;
@@ -9,11 +10,10 @@ export declare const daikinUdpDiscoveryPort = 30050;
 export declare const daikinUdpDiscoveryMessage = "DAIKIN_UDP/common/basic_info";
 export declare const daikinZeroconfType = "_dkapi._tcp.local.";
 export type TDaikinApiVariant = 'auto' | 'brp069' | 'brp072c' | 'airbase' | 'skyfi' | 'brp084';
-export type TDaikinSnapshotSource = 'http' | 'client' | 'manual' | 'snapshot' | 'runtime' | 'executor';
+export type TDaikinSnapshotSource = 'http' | 'manual' | 'snapshot' | 'runtime';
 export type TDaikinHvacMode = 'off' | 'fan_only' | 'dry' | 'cool' | 'heat' | 'heat_cool' | 'auto' | 'unknown' | string;
 export type TDaikinHvacAction = 'off' | 'idle' | 'cooling' | 'heating' | 'drying' | 'fan' | 'unknown';
 export type TDaikinPresetMode = 'none' | 'away' | 'boost' | 'eco' | string;
-export type TDaikinCommandAction = 'refresh' | 'set_control' | 'set_holiday' | 'set_advanced_mode' | 'set_streamer' | 'set_zone';
 export interface IDaikinValueMap {
     [key: string]: string | undefined;
 }
@@ -48,6 +48,7 @@ export interface IDaikinDeviceSnapshotInfo {
     ssl?: boolean;
     macAddress?: string;
     apiVariant: TDaikinApiVariant;
+    homeId?: string;
 }
 export interface IDaikinClimateSnapshot {
     power: boolean;
@@ -112,53 +113,17 @@ export interface IDaikinSnapshot {
     updatedAt: string;
     source: TDaikinSnapshotSource;
     error?: string;
+    /** Present only for a current observation from the public selected BRP069 protocol. */
+    nativeState?: plugins.ecobridgeDeviceManager.IDaikinState;
 }
-export interface IDaikinControlSettings {
-    mode?: string;
-    pow?: string;
-    stemp?: string | number;
-    shum?: string | number;
-    f_rate?: string;
-    f_dir?: string;
-}
-export interface IDaikinCommandRequest {
-    action: TDaikinCommandAction;
-    method?: 'GET' | 'POST';
-    path?: string;
-    query?: Record<string, string | number | boolean | undefined>;
-    protocol?: TDaikinApiVariant | 'legacy';
-    settings?: Partial<IDaikinControlSettings>;
-    mode?: string;
-    enabled?: boolean;
-    zoneId?: number;
-    zoneKey?: string;
-    zoneValue?: string;
-    service?: string;
-    target?: Record<string, unknown>;
-    data?: Record<string, unknown>;
-}
-export interface IDaikinCommandExecutor {
-    execute(requestArg: IDaikinCommandRequest): Promise<unknown>;
-}
-export interface IDaikinClientLike {
-    getSnapshot?: () => Promise<IDaikinSnapshot | Partial<IDaikinRawData>>;
-    getRawData?: () => Promise<Partial<IDaikinRawData>>;
-    getResource?: (pathArg: string, queryArg?: Record<string, string | number | boolean | undefined>) => Promise<IDaikinValueMap>;
-    execute?: (requestArg: IDaikinCommandRequest) => Promise<unknown>;
-    destroy?: () => Promise<void>;
-}
+/** Offline mapper input; this shape cannot authorize native setup or effects. */
 export interface IDaikinConfig {
     host?: string;
     url?: string;
     port?: number;
     ssl?: boolean;
     tls?: boolean;
-    verifySsl?: boolean;
-    apiKey?: string;
-    uuid?: string;
-    password?: string;
     apiVariant?: TDaikinApiVariant;
-    timeoutMs?: number;
     name?: string;
     manufacturer?: string;
     model?: string;
@@ -167,11 +132,9 @@ export interface IDaikinConfig {
     snapshot?: IDaikinSnapshot;
     rawData?: Partial<IDaikinRawData>;
     values?: IDaikinValueMap;
-    client?: IDaikinClientLike;
-    commandExecutor?: IDaikinCommandExecutor;
     online?: boolean;
 }
-export interface IHomeAssistantDaikinConfig extends IDaikinConfig {
+export interface IHomeAssistantDaikinConfig extends IDaikinNativeConfig {
 }
 export interface IDaikinManualEntry extends IDaikinConfig {
     id?: string;
@@ -220,3 +183,20 @@ export interface IDaikinRefreshResult {
     error?: string;
     data?: unknown;
 }
+/** Live setup is an explicit selected, unauthenticated BRP069 LAN connection. */
+export interface IDaikinIntegrationOptions {
+    readonly homeId?: string;
+    readonly capacity?: number;
+}
+export interface IDaikinNativeConfig {
+    homeId: string;
+    apiVariant: 'brp069';
+    host: string;
+    expectedMac: string;
+    allowPlaintext: true;
+    name?: string;
+    port?: number;
+    timeoutMs?: number;
+    maxResponseBytes?: number;
+    maxPendingOperations?: number;
+}

package/dist_ts/integrations/daikin/daikin.types.js

@@ -8,4 +8,4 @@ export const daikinUdpSourcePort = 30000;
 export const daikinUdpDiscoveryPort = 30050;
 export const daikinUdpDiscoveryMessage = 'DAIKIN_UDP/common/basic_info';
 export const daikinZeroconfType = '_dkapi._tcp.local.';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGFpa2luLnR5cGVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vdHMvaW50ZWdyYXRpb25zL2RhaWtpbi9kYWlraW4udHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxDQUFDLE1BQU0sWUFBWSxHQUFHLFFBQVEsQ0FBQztBQUNyQyxNQUFNLENBQUMsTUFBTSxpQkFBaUIsR0FBRyxXQUFXLENBQUM7QUFDN0MsTUFBTSxDQUFDLE1BQU0scUJBQXFCLEdBQUcsRUFBRSxDQUFDO0FBQ3hDLE1BQU0sQ0FBQyxNQUFNLHNCQUFzQixHQUFHLEdBQUcsQ0FBQztBQUMxQyxNQUFNLENBQUMsTUFBTSxlQUFlLEdBQUcsSUFBSSxDQUFDO0FBQ3BDLE1BQU0sQ0FBQyxNQUFNLHNCQUFzQixHQUFHLEtBQUssQ0FBQztBQUM1QyxNQUFNLENBQUMsTUFBTSxtQkFBbUIsR0FBRyxLQUFLLENBQUM7QUFDekMsTUFBTSxDQUFDLE1BQU0sc0JBQXNCLEdBQUcsS0FBSyxDQUFDO0FBQzVDLE1BQU0sQ0FBQyxNQUFNLHlCQUF5QixHQUFHLDhCQUE4QixDQUFDO0FBQ3hFLE1BQU0sQ0FBQyxNQUFNLGtCQUFrQixHQUFHLG9CQUFvQixDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGFpa2luLnR5cGVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vdHMvaW50ZWdyYXRpb25zL2RhaWtpbi9kYWlraW4udHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsTUFBTSxDQUFDLE1BQU0sWUFBWSxHQUFHLFFBQVEsQ0FBQztBQUNyQyxNQUFNLENBQUMsTUFBTSxpQkFBaUIsR0FBRyxXQUFXLENBQUM7QUFDN0MsTUFBTSxDQUFDLE1BQU0scUJBQXFCLEdBQUcsRUFBRSxDQUFDO0FBQ3hDLE1BQU0sQ0FBQyxNQUFNLHNCQUFzQixHQUFHLEdBQUcsQ0FBQztBQUMxQyxNQUFNLENBQUMsTUFBTSxlQUFlLEdBQUcsSUFBSSxDQUFDO0FBQ3BDLE1BQU0sQ0FBQyxNQUFNLHNCQUFzQixHQUFHLEtBQUssQ0FBQztBQUM1QyxNQUFNLENBQUMsTUFBTSxtQkFBbUIsR0FBRyxLQUFLLENBQUM7QUFDekMsTUFBTSxDQUFDLE1BQU0sc0JBQXNCLEdBQUcsS0FBSyxDQUFDO0FBQzVDLE1BQU0sQ0FBQyxNQUFNLHlCQUF5QixHQUFHLDhCQUE4QixDQUFDO0FBQ3hFLE1BQU0sQ0FBQyxNQUFNLGtCQUFrQixHQUFHLG9CQUFvQixDQUFDIn0=

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

@@ -0,0 +1,5 @@
+import type { IDaikinNativeConfig } from './daikin.types.js';
+export declare const daikinObject: (valueArg: unknown, nameArg: string) => Record<string, unknown>;
+export declare const daikinKeys: (valueArg: Record<string, unknown>, allowedArg: readonly string[]) => void;
+/** Device address, MAC and protocol limits are validated by the public DaikinProtocol. */
+export declare const normalizeDaikinConfig: (valueArg: IDaikinNativeConfig) => Readonly<IDaikinNativeConfig>;

package/dist_ts/integrations/daikin/daikin.validation.js

@@ -0,0 +1,53 @@
+export const daikinObject = (valueArg, nameArg) => {
+    if (!valueArg || typeof valueArg !== 'object' || Object.getPrototypeOf(valueArg) !== Object.prototype) {
+        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} accepts only enumerable own data fields.`);
+        }
+        Object.defineProperty(result, key, { value: descriptor.value, enumerable: true });
+    }
+    return result;
+};
+export const daikinKeys = (valueArg, allowedArg) => {
+    if (Object.keys(valueArg).some((keyArg) => !allowedArg.includes(keyArg)))
+        throw new TypeError('Daikin arguments contain unsupported fields.');
+};
+const text = (valueArg, nameArg, maximumArg) => {
+    if (typeof valueArg !== 'string' || valueArg.length === 0 || 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;
+};
+const optionalNumber = (valueArg, nameArg) => {
+    if (valueArg === undefined)
+        return undefined;
+    if (typeof valueArg !== 'number')
+        throw new TypeError(`${nameArg} must be a number.`);
+    return valueArg;
+};
+/** Device address, MAC and protocol limits are validated by the public DaikinProtocol. */
+export const normalizeDaikinConfig = (valueArg) => {
+    const value = daikinObject(valueArg, 'Daikin configuration');
+    daikinKeys(value, ['homeId', 'apiVariant', 'host', 'expectedMac', 'allowPlaintext', 'name', 'port', 'timeoutMs', 'maxResponseBytes', 'maxPendingOperations']);
+    if (value.apiVariant !== 'brp069')
+        throw new TypeError('Daikin live control requires the explicitly selected brp069 family.');
+    if (value.allowPlaintext !== true)
+        throw new TypeError('Daikin BRP069 requires explicit allowPlaintext: true for unauthenticated LAN HTTP.');
+    const result = {
+        allowPlaintext: true, homeId: text(value.homeId, 'Daikin home ID', 256), apiVariant: 'brp069',
+        host: text(value.host, 'Daikin selected IPv4', 64), expectedMac: text(value.expectedMac, 'Daikin expected adapter MAC', 12).toUpperCase(),
+    };
+    if (value.name !== undefined)
+        result.name = text(value.name, 'Daikin name', 256);
+    for (const key of ['port', 'timeoutMs', 'maxResponseBytes', 'maxPendingOperations']) {
+        const number = optionalNumber(value[key], `Daikin ${key}`);
+        if (number !== undefined)
+            result[key] = number;
+    }
+    return Object.freeze(result);
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,37 +1,45 @@
-import type { IDeconzConfig, IDeconzGatewayConfig, IDeconzGroupActionPatch, IDeconzLightStatePatch, IDeconzSensorConfigPatch, IDeconzSensorStatePatch, IDeconzSnapshot, IDeconzWebsocketEvent } from './deconz.types.js';
+import { NativeIntegrationOwner } from '../../core/classes.nativeintegrationowner.js';
+import type { IIntegrationSetupContext } from '../../core/types.js';
+import type { IDeconzConfig, IDeconzGatewayConfig, IDeconzGroupActionPatch, IDeconzIntegrationOptions, IDeconzLightStatePatch, IDeconzSensorConfigPatch, IDeconzSensorStatePatch, IDeconzSnapshot, IDeconzWebsocketEvent, IDeconzWriteResult } from './deconz.types.js';
 export declare class DeconzRequestError extends Error {
     readonly apiErrorType?: number | undefined;
     constructor(messageArg: string, apiErrorType?: number | undefined);
 }
+export declare class DeconzWriteError extends Error {
+    readonly effectOutcome: 'indeterminate';
+    constructor();
+}
+export interface IDeconzClientOperation {
+    readonly isHealthy: boolean;
+    getSnapshot(signalArg?: AbortSignal): Promise<IDeconzSnapshot>;
+    setLightState(idArg: string, patchArg: IDeconzLightStatePatch, signalArg?: AbortSignal): Promise<IDeconzWriteResult>;
+    setGroupState(idArg: string, patchArg: IDeconzGroupActionPatch, signalArg?: AbortSignal): Promise<IDeconzWriteResult>;
+    setSensorConfig(idArg: string, patchArg: IDeconzSensorConfigPatch, signalArg?: AbortSignal): Promise<IDeconzWriteResult>;
+    setSensorState(idArg: string, patchArg: IDeconzSensorStatePatch, signalArg?: AbortSignal): Promise<IDeconzWriteResult>;
+}
+/** Credentials and persistence resources are supplied by the independently selected host. */
 export declare class DeconzClient {
-    private readonly abortSignal?;
-    private readonly config;
-    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);
+    #private;
+    constructor(configArg: IDeconzConfig, contextArg: IIntegrationSetupContext, optionsArg?: IDeconzIntegrationOptions, ownerArg?: NativeIntegrationOwner);
     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>>;
+    get canCreateCredential(): boolean;
+    getSnapshot(signalArg?: AbortSignal): Promise<IDeconzSnapshot>;
+    getGatewayConfig(signalArg?: AbortSignal): Promise<IDeconzGatewayConfig>;
+    /** Keeps a runtime command, its actual callbacks, and its readback on one shared operation lease. */
+    execute<TResult>(workArg: (clientArg: IDeconzClientOperation) => Promise<TResult>, signalArg?: AbortSignal): Promise<{
+        result: TResult;
+        observation?: IDeconzWriteResult;
+    }>;
+    acquireApiKey(deviceTypeArg?: string, signalArg?: AbortSignal): Promise<string>;
+    createCredential(apiKeyArg: string, signalArg?: AbortSignal): Promise<void>;
+    setLightState(idArg: string, patchArg: IDeconzLightStatePatch, signalArg?: AbortSignal): Promise<IDeconzWriteResult>;
+    setGroupState(idArg: string, patchArg: IDeconzGroupActionPatch, signalArg?: AbortSignal): Promise<IDeconzWriteResult>;
+    setSensorConfig(idArg: string, patchArg: IDeconzSensorConfigPatch, signalArg?: AbortSignal): Promise<IDeconzWriteResult>;
+    setSensorState(idArg: string, patchArg: IDeconzSensorStatePatch, signalArg?: AbortSignal): Promise<IDeconzWriteResult>;
+    recallScene(groupIdArg: string, sceneIdArg: string, signalArg?: AbortSignal): Promise<IDeconzWriteResult>;
+    put(pathArg: string, dataArg: Record<string, unknown>, signalArg?: AbortSignal): Promise<IDeconzWriteResult>;
+    post(pathArg: string, dataArg: Record<string, unknown>, signalArg?: AbortSignal): Promise<never>;
+    subscribeToEvents(handlerArg: (eventArg: IDeconzWebsocketEvent) => unknown, signalArg?: AbortSignal, errorHandlerArg?: (errorArg: Error) => unknown): Promise<() => Promise<void>>;
     destroy(): Promise<void>;
-    private requestJson;
-    private fetchJson;
-    private assertWriteAcknowledgement;
-    private assertActive;
-    private assertGatewayIdentity;
-    private resourceId;
+    retryCleanup(): Promise<void>;
 }