@smarthome.exchange/integrations 1.0.0 → 2.0.0

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

@@ -1,236 +1,148 @@
-const DEFAULT_NANOLEAF_PORT = 16021;
+import * as plugins from '../../plugins.js';
+import { NoSqlConfigStore } from '../../core/classes.configstore.js';
+import { createNanoleafCredentialStore, nanoleafCredentialKey, readNanoleafCredential } from './nanoleaf.credentials.js';
+import { normalizeNanoleafConfig } from './nanoleaf.validation.js';
 export class NanoleafClient {
-    config;
-    constructor(config) {
-        this.config = config;
-    }
-    async getSnapshot() {
-        if (this.config.snapshot) {
-            return this.normalizeSnapshot(this.config.snapshot);
-        }
-        if (this.canRequest()) {
-            const controllerInfo = await this.requestJson(this.authenticatedPath(''));
-            return this.normalizeSnapshot({
-                controllerInfo,
-                state: controllerInfo.state ?? {},
-                effects: controllerInfo.effects ?? {},
-                panelLayout: controllerInfo.panelLayout,
-                rhythm: controllerInfo.rhythm,
-            });
-        }
-        return this.normalizeSnapshot({
-            controllerInfo: this.config.controllerInfo ?? this.defaultControllerInfo(),
-            state: this.config.state ?? this.config.controllerInfo?.state ?? {},
-            effects: this.config.effects ?? this.config.controllerInfo?.effects ?? {},
-            panelLayout: this.config.panelLayout ?? this.config.controllerInfo?.panelLayout,
-            rhythm: this.config.rhythm ?? this.config.controllerInfo?.rhythm,
-        });
-    }
-    async getControllerInfo() {
-        return (await this.getSnapshot()).controllerInfo;
-    }
-    async getState() {
-        if (this.config.snapshot || this.config.state || this.config.controllerInfo?.state || !this.canRequest()) {
-            return (await this.getSnapshot()).state;
-        }
-        return this.requestJson(this.authenticatedPath('/state'));
-    }
-    async getEffects() {
-        if (this.config.snapshot || this.config.effects || this.config.controllerInfo?.effects || !this.canRequest()) {
-            return (await this.getSnapshot()).effects;
-        }
-        return this.requestJson(this.authenticatedPath('/effects'));
-    }
-    async getPanelLayout() {
-        return (await this.getSnapshot()).panelLayout;
-    }
-    async getRhythm() {
-        return (await this.getSnapshot()).rhythm;
-    }
-    async turnOn() {
-        await this.setState({ on: { value: true } });
-    }
-    async turnOff(transitionArg) {
-        if (transitionArg === undefined) {
-            await this.setState({ on: { value: false } });
-            return;
-        }
-        await this.setState({ on: { value: false }, brightness: { value: 0, duration: transitionArg } });
-    }
-    async setBrightness(percentArg, transitionArg) {
-        await this.setState({
-            brightness: {
-                value: this.clamp(Math.round(percentArg), 0, 100),
-                duration: transitionArg,
+    #config;
+    #protocol;
+    #ownsStore;
+    #lifetime = new AbortController();
+    #operations = new Set();
+    #store;
+    #healthy = false;
+    #closed = false;
+    #closePromise;
+    #retryPromise;
+    #protocolClosed = false;
+    #removeParentAbort = () => undefined;
+    constructor(configArg, ownerArg, signalArg, homeIdArg) {
+        this.#config = normalizeNanoleafConfig(configArg);
+        if (signalArg !== undefined && !(signalArg instanceof AbortSignal))
+            throw new TypeError('Nanoleaf lifetime signal must be an AbortSignal.');
+        if (homeIdArg === undefined)
+            throw new TypeError('Nanoleaf client requires the admitted host home.');
+        const store = createNanoleafCredentialStore(this.#config, homeIdArg, ownerArg);
+        this.#store = store.store;
+        this.#ownsStore = store.owned;
+        this.#protocol = new plugins.ecobridgeDeviceManager.NanoleafProtocol({
+            origin: this.#config.origin, expectedSerialNumber: this.#config.expectedSerialNumber,
+            expectedModel: this.#config.expectedModel, allowUnencryptedHttp: this.#config.allowUnencryptedHttp,
+            ca: this.#config.certificateAuthority, timeoutMs: this.#config.timeoutMs,
+            maxResponseBytes: this.#config.maxResponseBytes, maxPendingOperations: this.#config.maxPendingOperations,
+            getAuthToken: async (signal) => {
+                signal.throwIfAborted();
+                const currentStore = this.#store;
+                if (!currentStore)
+                    throw new Error('Nanoleaf client is destroyed.');
+                await currentStore.initialize({ signal });
+                signal.throwIfAborted();
+                const credential = await currentStore.get(nanoleafCredentialKey(this.#config));
+                signal.throwIfAborted();
+                return readNanoleafCredential(this.#config, credential);
             },
         });
-    }
-    async setHue(hueArg) {
-        await this.setState({ hue: { value: this.clamp(Math.round(hueArg), 0, 360) } });
-    }
-    async setSaturation(saturationArg) {
-        await this.setState({ sat: { value: this.clamp(Math.round(saturationArg), 0, 100) } });
-    }
-    async setColorTemperature(kelvinArg) {
-        await this.setState({ ct: { value: Math.round(kelvinArg) } });
-    }
-    async setState(stateArg) {
-        this.applyStatePatch(stateArg);
-        if (this.canRequest()) {
-            await this.requestJson(this.authenticatedPath('/state'), {
-                method: 'PUT',
-                body: stateArg,
-            });
-            return;
-        }
-        this.assertFixtureMode();
-    }
-    async setEffect(effectArg) {
-        this.applyEffectsPatch({ select: effectArg });
-        if (this.canRequest()) {
-            await this.requestJson(this.authenticatedPath('/effects'), {
-                method: 'PUT',
-                body: { select: effectArg },
-            });
-            return;
-        }
-        this.assertFixtureMode();
-    }
-    async writeEffectsCommand(commandArg) {
-        if (this.canRequest()) {
-            await this.requestJson(this.authenticatedPath('/effects'), {
-                method: 'PUT',
-                body: { write: commandArg },
-            });
-            return;
-        }
-        this.assertFixtureMode();
-    }
-    async identify() {
-        if (this.canRequest()) {
-            await this.requestJson(this.authenticatedPath('/identify'), { method: 'PUT' });
-            return;
-        }
-        this.assertFixtureMode();
-    }
-    async createAuthToken() {
-        return {
-            success: false,
-            error: 'Nanoleaf pairing/token generation is not implemented. Put the controller in pairing mode and provide an existing authToken.',
-        };
-    }
-    async destroy() { }
-    normalizeSnapshot(snapshotArg) {
-        const controllerInfo = snapshotArg.controllerInfo;
-        const state = snapshotArg.state ?? controllerInfo.state ?? {};
-        const effects = snapshotArg.effects ?? controllerInfo.effects ?? {};
-        const panelLayout = snapshotArg.panelLayout ?? controllerInfo.panelLayout;
-        const rhythm = snapshotArg.rhythm ?? controllerInfo.rhythm;
-        controllerInfo.state = state;
-        controllerInfo.effects = effects;
-        controllerInfo.panelLayout = panelLayout;
-        controllerInfo.rhythm = rhythm;
-        return { controllerInfo, state, effects, panelLayout, rhythm };
-    }
-    applyStatePatch(stateArg) {
-        const state = this.ensureMutableState();
-        if (stateArg.on) {
-            state.on = { ...state.on, ...stateArg.on };
-        }
-        if (stateArg.brightness) {
-            state.brightness = { ...state.brightness, ...stateArg.brightness };
-        }
-        if (stateArg.hue) {
-            state.hue = { ...state.hue, ...stateArg.hue };
-        }
-        if (stateArg.sat) {
-            state.sat = { ...state.sat, ...stateArg.sat };
-        }
-        if (stateArg.ct) {
-            state.ct = { ...state.ct, ...stateArg.ct };
-        }
-    }
-    applyEffectsPatch(effectsArg) {
-        const effects = this.ensureMutableEffects();
-        Object.assign(effects, effectsArg);
-    }
-    ensureMutableState() {
-        if (this.config.snapshot) {
-            this.config.snapshot.state ||= {};
-            this.config.snapshot.controllerInfo.state = this.config.snapshot.state;
-            return this.config.snapshot.state;
-        }
-        this.config.state ||= this.config.controllerInfo?.state ?? {};
-        if (this.config.controllerInfo) {
-            this.config.controllerInfo.state = this.config.state;
-        }
-        return this.config.state;
-    }
-    ensureMutableEffects() {
-        if (this.config.snapshot) {
-            this.config.snapshot.effects ||= {};
-            this.config.snapshot.controllerInfo.effects = this.config.snapshot.effects;
-            return this.config.snapshot.effects;
-        }
-        this.config.effects ||= this.config.controllerInfo?.effects ?? {};
-        if (this.config.controllerInfo) {
-            this.config.controllerInfo.effects = this.config.effects;
-        }
-        return this.config.effects;
-    }
-    assertFixtureMode() {
-        if (!this.hasFixtureData()) {
-            throw new Error('Nanoleaf host and authToken are required when snapshot/manual config data is not provided.');
-        }
-    }
-    hasFixtureData() {
-        return Boolean(this.config.snapshot || this.config.controllerInfo || this.config.state || this.config.effects || this.config.panelLayout || this.config.rhythm);
-    }
-    canRequest() {
-        return Boolean(this.config.host && this.authToken());
-    }
-    authToken() {
-        return this.config.authToken || this.config.token;
-    }
-    authenticatedPath(pathArg) {
-        const token = this.authToken();
-        if (!token) {
-            throw new Error('Nanoleaf authToken is required for local HTTP requests.');
-        }
-        return `/api/v1/${encodeURIComponent(token)}${pathArg}`;
-    }
-    async requestJson(pathArg, optionsArg = {}) {
-        const response = await globalThis.fetch(`${this.baseUrl()}${pathArg}`, {
-            method: optionsArg.method ?? (optionsArg.body === undefined ? 'GET' : 'POST'),
-            headers: optionsArg.body === undefined ? undefined : { 'content-type': 'application/json' },
-            body: optionsArg.body === undefined ? undefined : JSON.stringify(optionsArg.body),
-        });
-        const text = await response.text();
-        if (!response.ok) {
-            throw new Error(`Nanoleaf request ${pathArg} failed with HTTP ${response.status}: ${text}`);
-        }
-        if (!text) {
-            return undefined;
-        }
-        return JSON.parse(text);
-    }
-    baseUrl() {
-        if (!this.config.host) {
-            throw new Error('Nanoleaf host is required for local HTTP requests.');
-        }
-        const protocol = this.config.protocol ?? 'http';
-        const port = this.config.port ?? DEFAULT_NANOLEAF_PORT;
-        return `${protocol}://${this.config.host}:${port}`;
-    }
-    defaultControllerInfo() {
-        return {
-            name: 'Nanoleaf',
-            manufacturer: 'Nanoleaf',
-            model: 'Nanoleaf Controller',
-        };
-    }
-    clamp(valueArg, minArg, maxArg) {
-        return Math.max(minArg, Math.min(maxArg, valueArg));
+        if (signalArg) {
+            const aborted = () => { void this.destroy(); };
+            signalArg.addEventListener('abort', aborted, { once: true });
+            this.#removeParentAbort = () => signalArg.removeEventListener('abort', aborted);
+            if (signalArg.aborted)
+                aborted();
+        }
+    }
+    isHealthy() { return this.#healthy && !this.#closed; }
+    getSnapshot(signalArg) {
+        return this.#run(async (signal) => this.#snapshot(await this.#protocol.readSnapshot({ signal })), signalArg);
+    }
+    setPower(powerArg, signalArg) {
+        return this.#setState({ power: powerArg }, signalArg);
+    }
+    setBrightness(brightnessArg, signalArg) {
+        return this.#setState({ brightness: brightnessArg }, signalArg);
+    }
+    setColorTemperature(kelvinArg, signalArg) {
+        return this.#setState({ colorTemperatureKelvin: kelvinArg }, signalArg);
+    }
+    #setState(commandArg, signalArg) {
+        return this.#run(async (signal) => {
+            const result = await this.#protocol.setState(commandArg, { signal });
+            return Object.freeze({ acceptance: result.acceptance, snapshot: this.#snapshot(result.snapshot) });
+        }, signalArg);
+    }
+    selectEffect(effectArg, signalArg) {
+        return this.#run(async (signal) => {
+            const result = await this.#protocol.selectEffect(effectArg, { signal });
+            return Object.freeze({ acceptance: result.acceptance, snapshot: this.#snapshot(result.snapshot) });
+        }, signalArg);
+    }
+    destroy() {
+        if (this.#closePromise)
+            return this.#closePromise;
+        this.#closed = true;
+        this.#healthy = false;
+        this.#removeParentAbort();
+        this.#closePromise = Promise.resolve().then(() => this.#drainCleanup());
+        this.#lifetime.abort();
+        return this.#closePromise;
+    }
+    /** Explicitly retries retained cleanup; no device operation is replayed. */
+    retryCleanup() {
+        if (!this.#closePromise)
+            return this.destroy();
+        if (this.#retryPromise)
+            return this.#retryPromise;
+        const retry = this.#closePromise.then(() => undefined, () => this.#drainCleanup(true));
+        this.#retryPromise = retry;
+        void retry.finally(() => { if (this.#retryPromise === retry)
+            this.#retryPromise = undefined; }).catch(() => undefined);
+        return retry;
+    }
+    async #drainCleanup(retryArg = false) {
+        const results = await Promise.allSettled([
+            Promise.resolve().then(async () => {
+                if (!this.#protocolClosed) {
+                    await this.#protocol.close();
+                    this.#protocolClosed = true;
+                }
+            }),
+            Promise.allSettled([...this.#operations]),
+        ]);
+        if (this.#ownsStore && this.#store) {
+            results.push(...await Promise.allSettled([Promise.resolve().then(async () => {
+                    if (retryArg)
+                        await this.#store?.retryCleanup();
+                    else
+                        await this.#store?.close();
+                    this.#store = undefined;
+                })]));
+        }
+        else if (this.#protocolClosed)
+            this.#store = undefined;
+        const failures = results.flatMap((resultArg) => resultArg.status === 'rejected' ? [resultArg.reason] : []);
+        if (failures.length)
+            throw new AggregateError(failures, 'Nanoleaf client cleanup failed.');
+    }
+    #snapshot(snapshotArg) {
+        return Object.freeze({ ...snapshotArg, homeId: this.#config.homeId, origin: this.#config.origin });
+    }
+    #run(workArg, signalArg) {
+        if (this.#closed)
+            return Promise.reject(new plugins.ecobridgeDeviceManager.NanoleafProtocolError('CLOSED', 'Nanoleaf client is destroyed.'));
+        if (this.#operations.size >= (this.#config.maxPendingOperations ?? 32)) {
+            return Promise.reject(new plugins.ecobridgeDeviceManager.NanoleafProtocolError('BUSY', 'Nanoleaf client operation capacity is exhausted.'));
+        }
+        if (signalArg !== undefined && !(signalArg instanceof AbortSignal))
+            return Promise.reject(new TypeError('Nanoleaf operation signal must be an AbortSignal.'));
+        const signal = signalArg ? AbortSignal.any([this.#lifetime.signal, signalArg]) : this.#lifetime.signal;
+        const operation = Promise.resolve().then(async () => {
+            if (signal.aborted)
+                throw new plugins.ecobridgeDeviceManager.NanoleafProtocolError('ABORTED', 'Nanoleaf operation was cancelled before admission.');
+            return workArg(signal);
+        }).then((resultArg) => { this.#healthy = !this.#closed && !signal.aborted; return resultArg; }, (errorArg) => {
+            this.#healthy = false;
+            throw errorArg;
+        }).finally(() => this.#operations.delete(operation));
+        this.#operations.add(operation);
+        return operation;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nanoleaf.classes.client.js","sourceRoot":"","sources":["../../../ts/integrations/nanoleaf/nanoleaf.classes.client.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nanoleaf.classes.client.js","sourceRoot":"","sources":["../../../ts/integrations/nanoleaf/nanoleaf.classes.client.ts"],"names":[],"mappings":"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"}

package/dist_ts/integrations/nanoleaf/nanoleaf.classes.configflow.d.ts

@@ -1,5 +1,10 @@
+import { type NativeIntegrationScope } from '../../core/classes.nativeintegrationowner.js';
 import type { IConfigFlow, IConfigFlowContext, IConfigFlowStep, IDiscoveryCandidate } from '../../core/types.js';
-import type { INanoleafConfig } from './nanoleaf.types.js';
+import type { INanoleafConfig, INanoleafIntegrationOptions } from './nanoleaf.types.js';
 export declare class NanoleafConfigFlow implements IConfigFlow<INanoleafConfig> {
+    #private;
+    constructor(ownerArg?: INanoleafIntegrationOptions, scopeArg?: NativeIntegrationScope);
+    destroy(): Promise<void>;
+    retryCleanup(): Promise<void>;
     start(candidateArg: IDiscoveryCandidate, contextArg: IConfigFlowContext): Promise<IConfigFlowStep<INanoleafConfig>>;
 }

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

@@ -1,26 +1,113 @@
-const DEFAULT_NANOLEAF_PORT = 16021;
+import * as plugins from '../../plugins.js';
+import { NativeIntegrationOwner } from '../../core/classes.nativeintegrationowner.js';
+import { createNanoleafCredentialStore, nanoleafCredential, nanoleafCredentialKey } from './nanoleaf.credentials.js';
+import { nanoleafKeys, nanoleafRecord, normalizeNanoleafConfig } from './nanoleaf.validation.js';
 export class NanoleafConfigFlow {
+    #scope;
+    #credentials;
+    constructor(ownerArg, scopeArg) {
+        this.#credentials = ownerArg && Object.freeze({ db: ownerArg.db, keyProvider: ownerArg.keyProvider });
+        this.#scope = scopeArg ?? new NativeIntegrationOwner('nanoleaf', { homeId: ownerArg?.homeId }).createFlowScope();
+    }
+    destroy() { return this.#scope.close(); }
+    retryCleanup() { return this.#scope.retryCleanup(); }
     async start(candidateArg, contextArg) {
-        void contextArg;
+        if (candidateArg.integrationDomain !== undefined && candidateArg.integrationDomain !== 'nanoleaf') {
+            return { kind: 'error', error: 'Nanoleaf config flow requires a Nanoleaf candidate.' };
+        }
+        let context;
+        try {
+            context = this.#scope.admit(contextArg);
+        }
+        catch {
+            return { kind: 'error', error: 'Nanoleaf config flow requires an open instance and the explicit matching host home.' };
+        }
         return {
-            kind: 'form',
-            title: 'Connect Nanoleaf',
-            description: 'Configure the local Nanoleaf HTTP endpoint with an existing auth token from the controller.',
+            kind: 'form', title: 'Connect selected Nanoleaf controller',
+            description: 'Provide the selected local IPv4 origin, serial and documented model. An existing token is validated and stored encrypted for the host-selected home; plaintext vendor HTTP requires explicit consent.',
             fields: [
-                { name: 'host', label: 'Host', type: 'text', required: true },
-                { name: 'port', label: 'Port', type: 'number', required: true },
-                { name: 'authToken', label: 'Auth token', type: 'password', required: true },
+                { name: 'origin', label: 'Selected HTTP(S) IPv4 origin', type: 'text', required: true },
+                { name: 'expectedSerialNumber', label: 'Expected serial number', type: 'text', required: true },
+                { name: 'expectedModel', label: 'Expected documented controller model', type: 'text', required: true },
+                { name: 'credentialKey', label: 'New encrypted credential reference', type: 'text', required: true },
+                { name: 'authToken', label: 'Existing controller token', type: 'password', required: true },
+                { name: 'allowUnencryptedHttp', label: 'Consent to plaintext local HTTP', type: 'boolean' },
+                { name: 'certificateAuthority', label: 'Trusted HTTPS controller PEM certificate', type: 'text' },
             ],
-            submit: async (valuesArg) => ({
-                kind: 'done',
-                title: 'Nanoleaf configured',
-                config: {
-                    host: String(valuesArg.host || candidateArg.host || ''),
-                    port: typeof valuesArg.port === 'number' ? valuesArg.port : candidateArg.port || DEFAULT_NANOLEAF_PORT,
-                    authToken: String(valuesArg.authToken || ''),
-                },
-            }),
+            submit: (valuesArg) => this.#submit(valuesArg, context),
         };
     }
+    async #submit(valuesArg, contextArg) {
+        let config;
+        let credential;
+        try {
+            const values = nanoleafRecord(valuesArg, 'config flow values');
+            nanoleafKeys(values, ['homeId', 'origin', 'expectedSerialNumber', 'expectedModel', 'credentialKey', 'authToken',
+                'allowUnencryptedHttp', 'certificateAuthority', 'timeoutMs', 'maxResponseBytes', 'maxPendingOperations']);
+            if (values.homeId !== undefined && values.homeId !== contextArg.homeId)
+                throw new TypeError('Nanoleaf form home conflicts with the host home.');
+            const { authToken, ...configuration } = values;
+            config = normalizeNanoleafConfig({ ...configuration, homeId: contextArg.homeId });
+            credential = nanoleafCredential(config, authToken);
+            this.#scope.admit(contextArg, config.homeId);
+        }
+        catch {
+            return { kind: 'error', error: 'Nanoleaf config flow values or host home are invalid, cancelled or closed.' };
+        }
+        return this.#scope.run(contextArg, config.homeId, async (leaseArg) => {
+            try {
+                const handle = createNanoleafCredentialStore(config, leaseArg.context.homeId, leaseArg.context.configStore ?? this.#credentials);
+                let protocol;
+                let protocolClosed = false;
+                let storeClosed = !handle.owned;
+                let firstStoreCleanup = true;
+                // One admitted credential-validation operation owns its protocol and optional store.
+                leaseArg.own(async () => {
+                    const results = await Promise.allSettled([
+                        Promise.resolve().then(async () => {
+                            if (protocol && !protocolClosed) {
+                                await protocol.close();
+                                protocolClosed = true;
+                            }
+                        }),
+                        Promise.resolve().then(async () => {
+                            if (!storeClosed) {
+                                // Failed lease callbacks run again only on explicit owner cleanup retry.
+                                if (firstStoreCleanup) {
+                                    firstStoreCleanup = false;
+                                    await handle.store.close();
+                                }
+                                else
+                                    await handle.store.retryCleanup();
+                                storeClosed = true;
+                            }
+                        }),
+                    ]);
+                    const failures = results.flatMap((resultArg) => resultArg.status === 'rejected' ? [resultArg.reason] : []);
+                    if (failures.length)
+                        throw new AggregateError(failures, 'Nanoleaf flow resource cleanup failed.');
+                });
+                await handle.store.initialize({ signal: leaseArg.signal });
+                leaseArg.assertOpen();
+                protocol = new plugins.ecobridgeDeviceManager.NanoleafProtocol({ origin: config.origin,
+                    expectedSerialNumber: config.expectedSerialNumber, expectedModel: config.expectedModel,
+                    getAuthToken: () => credential.authToken, allowUnencryptedHttp: config.allowUnencryptedHttp,
+                    ca: config.certificateAuthority, timeoutMs: config.timeoutMs, maxResponseBytes: config.maxResponseBytes,
+                    maxPendingOperations: config.maxPendingOperations });
+                await protocol.readSnapshot({ signal: leaseArg.signal });
+                leaseArg.assertOpen();
+                await handle.store.create(nanoleafCredentialKey(config), credential);
+                leaseArg.assertOpen();
+                return { kind: 'done', title: 'Nanoleaf identity verified and token stored encrypted', config };
+            }
+            catch {
+                return { kind: 'error', error: 'Nanoleaf controller validation or encrypted credential persistence failed.' };
+            }
+        }).catch((errorArg) => {
+            if (errorArg instanceof AggregateError)
+                throw errorArg;
+            return { kind: 'error', error: 'Nanoleaf config flow was cancelled or closed.' };
+        });
+    }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmFub2xlYWYuY2xhc3Nlcy5jb25maWdmbG93LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vdHMvaW50ZWdyYXRpb25zL25hbm9sZWFmL25hbm9sZWFmLmNsYXNzZXMuY29uZmlnZmxvdy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFHQSxNQUFNLHFCQUFxQixHQUFHLEtBQUssQ0FBQztBQUVwQyxNQUFNLE9BQU8sa0JBQWtCO0lBQ3RCLEtBQUssQ0FBQyxLQUFLLENBQUMsWUFBaUMsRUFBRSxVQUE4QjtRQUNsRixLQUFLLFVBQVUsQ0FBQztRQUNoQixPQUFPO1lBQ0wsSUFBSSxFQUFFLE1BQU07WUFDWixLQUFLLEVBQUUsa0JBQWtCO1lBQ3pCLFdBQVcsRUFBRSw2RkFBNkY7WUFDMUcsTUFBTSxFQUFFO2dCQUNOLEVBQUUsSUFBSSxFQUFFLE1BQU0sRUFBRSxLQUFLLEVBQUUsTUFBTSxFQUFFLElBQUksRUFBRSxNQUFNLEVBQUUsUUFBUSxFQUFFLElBQUksRUFBRTtnQkFDN0QsRUFBRSxJQUFJLEVBQUUsTUFBTSxFQUFFLEtBQUssRUFBRSxNQUFNLEVBQUUsSUFBSSxFQUFFLFFBQVEsRUFBRSxRQUFRLEVBQUUsSUFBSSxFQUFFO2dCQUMvRCxFQUFFLElBQUksRUFBRSxXQUFXLEVBQUUsS0FBSyxFQUFFLFlBQVksRUFBRSxJQUFJLEVBQUUsVUFBVSxFQUFFLFFBQVEsRUFBRSxJQUFJLEVBQUU7YUFDN0U7WUFDRCxNQUFNLEVBQUUsS0FBSyxFQUFFLFNBQVMsRUFBRSxFQUFFLENBQUMsQ0FBQztnQkFDNUIsSUFBSSxFQUFFLE1BQU07Z0JBQ1osS0FBSyxFQUFFLHFCQUFxQjtnQkFDNUIsTUFBTSxFQUFFO29CQUNOLElBQUksRUFBRSxNQUFNLENBQUMsU0FBUyxDQUFDLElBQUksSUFBSSxZQUFZLENBQUMsSUFBSSxJQUFJLEVBQUUsQ0FBQztvQkFDdkQsSUFBSSxFQUFFLE9BQU8sU0FBUyxDQUFDLElBQUksS0FBSyxRQUFRLENBQUMsQ0FBQyxDQUFDLFNBQVMsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLFlBQVksQ0FBQyxJQUFJLElBQUkscUJBQXFCO29CQUN0RyxTQUFTLEVBQUUsTUFBTSxDQUFDLFNBQVMsQ0FBQyxTQUFTLElBQUksRUFBRSxDQUFDO2lCQUM3QzthQUNGLENBQUM7U0FDSCxDQUFDO0lBQ0osQ0FBQztDQUNGIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmFub2xlYWYuY2xhc3Nlcy5jb25maWdmbG93LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vdHMvaW50ZWdyYXRpb25zL25hbm9sZWFmL25hbm9sZWFmLmNsYXNzZXMuY29uZmlnZmxvdy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssT0FBTyxNQUFNLGtCQUFrQixDQUFDO0FBQzVDLE9BQU8sRUFBRSxzQkFBc0IsRUFBK0IsTUFBTSw4Q0FBOEMsQ0FBQztBQUduSCxPQUFPLEVBQUUsNkJBQTZCLEVBQUUsa0JBQWtCLEVBQUUscUJBQXFCLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUVySCxPQUFPLEVBQUUsWUFBWSxFQUFFLGNBQWMsRUFBRSx1QkFBdUIsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBRWpHLE1BQU0sT0FBTyxrQkFBa0I7SUFDcEIsTUFBTSxDQUF5QjtJQUMvQixZQUFZLENBQStCO0lBRXBELFlBQVksUUFBc0MsRUFBRSxRQUFpQztRQUNuRixJQUFJLENBQUMsWUFBWSxHQUFHLFFBQVEsSUFBSSxNQUFNLENBQUMsTUFBTSxDQUFDLEVBQUUsRUFBRSxFQUFFLFFBQVEsQ0FBQyxFQUFFLEVBQUUsV0FBVyxFQUFFLFFBQVEsQ0FBQyxXQUFXLEVBQUUsQ0FBQyxDQUFDO1FBQ3RHLElBQUksQ0FBQyxNQUFNLEdBQUcsUUFBUSxJQUFJLElBQUksc0JBQXNCLENBQUMsVUFBVSxFQUFFLEVBQUUsTUFBTSxFQUFFLFFBQVEsRUFBRSxNQUFNLEVBQUUsQ0FBQyxDQUFDLGVBQWUsRUFBRSxDQUFDO0lBQ25ILENBQUM7SUFFTSxPQUFPLEtBQW9CLE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQyxLQUFLLEVBQUUsQ0FBQyxDQUFDLENBQUM7SUFDeEQsWUFBWSxLQUFvQixPQUFPLElBQUksQ0FBQyxNQUFNLENBQUMsWUFBWSxFQUFFLENBQUMsQ0FBQyxDQUFDO0lBRXBFLEtBQUssQ0FBQyxLQUFLLENBQUMsWUFBaUMsRUFBRSxVQUE4QjtRQUNsRixJQUFJLFlBQVksQ0FBQyxpQkFBaUIsS0FBSyxTQUFTLElBQUksWUFBWSxDQUFDLGlCQUFpQixLQUFLLFVBQVUsRUFBRSxDQUFDO1lBQ2xHLE9BQU8sRUFBRSxJQUFJLEVBQUUsT0FBTyxFQUFFLEtBQUssRUFBRSxxREFBcUQsRUFBRSxDQUFDO1FBQ3pGLENBQUM7UUFDRCxJQUFJLE9BQWdDLENBQUM7UUFDckMsSUFBSSxDQUFDO1lBQUMsT0FBTyxHQUFHLElBQUksQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLFVBQVUsQ0FBQyxDQUFDO1FBQUMsQ0FBQztRQUNoRCxNQUFNLENBQUM7WUFBQyxPQUFPLEVBQUUsSUFBSSxFQUFFLE9BQU8sRUFBRSxLQUFLLEVBQUUscUZBQXFGLEVBQUUsQ0FBQztRQUFDLENBQUM7UUFDakksT0FBTztZQUNMLElBQUksRUFBRSxNQUFNLEVBQUUsS0FBSyxFQUFFLHNDQUFzQztZQUMzRCxXQUFXLEVBQUUsdU1BQXVNO1lBQ3BOLE1BQU0sRUFBRTtnQkFDTixFQUFFLElBQUksRUFBRSxRQUFRLEVBQUUsS0FBSyxFQUFFLDhCQUE4QixFQUFFLElBQUksRUFBRSxNQUFNLEVBQUUsUUFBUSxFQUFFLElBQUksRUFBRTtnQkFDdkYsRUFBRSxJQUFJLEVBQUUsc0JBQXNCLEVBQUUsS0FBSyxFQUFFLHdCQUF3QixFQUFFLElBQUksRUFBRSxNQUFNLEVBQUUsUUFBUSxFQUFFLElBQUksRUFBRTtnQkFDL0YsRUFBRSxJQUFJLEVBQUUsZUFBZSxFQUFFLEtBQUssRUFBRSxzQ0FBc0MsRUFBRSxJQUFJLEVBQUUsTUFBTSxFQUFFLFFBQVEsRUFBRSxJQUFJLEVBQUU7Z0JBQ3RHLEVBQUUsSUFBSSxFQUFFLGVBQWUsRUFBRSxLQUFLLEVBQUUsb0NBQW9DLEVBQUUsSUFBSSxFQUFFLE1BQU0sRUFBRSxRQUFRLEVBQUUsSUFBSSxFQUFFO2dCQUNwRyxFQUFFLElBQUksRUFBRSxXQUFXLEVBQUUsS0FBSyxFQUFFLDJCQUEyQixFQUFFLElBQUksRUFBRSxVQUFVLEVBQUUsUUFBUSxFQUFFLElBQUksRUFBRTtnQkFDM0YsRUFBRSxJQUFJLEVBQUUsc0JBQXNCLEVBQUUsS0FBSyxFQUFFLGlDQUFpQyxFQUFFLElBQUksRUFBRSxTQUFTLEVBQUU7Z0JBQzNGLEVBQUUsSUFBSSxFQUFFLHNCQUFzQixFQUFFLEtBQUssRUFBRSwwQ0FBMEMsRUFBRSxJQUFJLEVBQUUsTUFBTSxFQUFFO2FBQ2xHO1lBQ0QsTUFBTSxFQUFFLENBQUMsU0FBUyxFQUFFLEVBQUUsQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLFNBQVMsRUFBRSxPQUFPLENBQUM7U0FDeEQsQ0FBQztJQUNKLENBQUM7SUFFRCxLQUFLLENBQUMsT0FBTyxDQUFDLFNBQWtDLEVBQUUsVUFBbUM7UUFDbkYsSUFBSSxNQUFpQyxDQUFDO1FBQ3RDLElBQUksVUFBaUQsQ0FBQztRQUN0RCxJQUFJLENBQUM7WUFDSCxNQUFNLE1BQU0sR0FBRyxjQUFjLENBQUMsU0FBUyxFQUFFLG9CQUFvQixDQUFDLENBQUM7WUFDL0QsWUFBWSxDQUFDLE1BQU0sRUFBRSxDQUFDLFFBQVEsRUFBRSxRQUFRLEVBQUUsc0JBQXNCLEVBQUUsZUFBZSxFQUFFLGVBQWUsRUFBRSxXQUFXO2dCQUM3RyxzQkFBc0IsRUFBRSxzQkFBc0IsRUFBRSxXQUFXLEVBQUUsa0JBQWtCLEVBQUUsc0JBQXNCLENBQUMsQ0FBQyxDQUFDO1lBQzVHLElBQUksTUFBTSxDQUFDLE1BQU0sS0FBSyxTQUFTLElBQUksTUFBTSxDQUFDLE1BQU0sS0FBSyxVQUFVLENBQUMsTUFBTTtnQkFBRSxNQUFNLElBQUksU0FBUyxDQUFDLGtEQUFrRCxDQUFDLENBQUM7WUFDaEosTUFBTSxFQUFFLFNBQVMsRUFBRSxHQUFHLGFBQWEsRUFBRSxHQUFHLE1BQU0sQ0FBQztZQUMvQyxNQUFNLEdBQUcsdUJBQXVCLENBQUMsRUFBRSxHQUFHLGFBQWEsRUFBRSxNQUFNLEVBQUUsVUFBVSxDQUFDLE1BQU0sRUFBRSxDQUFDLENBQUM7WUFDbEYsVUFBVSxHQUFHLGtCQUFrQixDQUFDLE1BQU0sRUFBRSxTQUFTLENBQUMsQ0FBQztZQUNuRCxJQUFJLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxVQUFVLEVBQUUsTUFBTSxDQUFDLE1BQU0sQ0FBQyxDQUFDO1FBQy9DLENBQUM7UUFBQyxNQUFNLENBQUM7WUFBQyxPQUFPLEVBQUUsSUFBSSxFQUFFLE9BQU8sRUFBRSxLQUFLLEVBQUUsNEVBQTRFLEVBQUUsQ0FBQztRQUFDLENBQUM7UUFDMUgsT0FBTyxJQUFJLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxVQUFVLEVBQUUsTUFBTSxDQUFDLE1BQU0sRUFBRSxLQUFLLEVBQUUsUUFBUSxFQUE2QyxFQUFFO1lBQzlHLElBQUksQ0FBQztnQkFDSCxNQUFNLE1BQU0sR0FBRyw2QkFBNkIsQ0FBQyxNQUFNLEVBQUUsUUFBUSxDQUFDLE9BQU8sQ0FBQyxNQUFNLEVBQUUsUUFBUSxDQUFDLE9BQU8sQ0FBQyxXQUFXLElBQUksSUFBSSxDQUFDLFlBQVksQ0FBQyxDQUFDO2dCQUNqSSxJQUFJLFFBQXFFLENBQUM7Z0JBQzFFLElBQUksY0FBYyxHQUFHLEtBQUssQ0FBQztnQkFDM0IsSUFBSSxXQUFXLEdBQUcsQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDO2dCQUNoQyxJQUFJLGlCQUFpQixHQUFHLElBQUksQ0FBQztnQkFDN0IscUZBQXFGO2dCQUNyRixRQUFRLENBQUMsR0FBRyxDQUFDLEtBQUssSUFBSSxFQUFFO29CQUN0QixNQUFNLE9BQU8sR0FBRyxNQUFNLE9BQU8sQ0FBQyxVQUFVLENBQUM7d0JBQ3ZDLE9BQU8sQ0FBQyxPQUFPLEVBQUUsQ0FBQyxJQUFJLENBQUMsS0FBSyxJQUFJLEVBQUU7NEJBQ2hDLElBQUksUUFBUSxJQUFJLENBQUMsY0FBYyxFQUFFLENBQUM7Z0NBQUMsTUFBTSxRQUFRLENBQUMsS0FBSyxFQUFFLENBQUM7Z0NBQUMsY0FBYyxHQUFHLElBQUksQ0FBQzs0QkFBQyxDQUFDO3dCQUNyRixDQUFDLENBQUM7d0JBQ0YsT0FBTyxDQUFDLE9BQU8sRUFBRSxDQUFDLElBQUksQ0FBQyxLQUFLLElBQUksRUFBRTs0QkFDaEMsSUFBSSxDQUFDLFdBQVcsRUFBRSxDQUFDO2dDQUNqQix5RUFBeUU7Z0NBQ3pFLElBQUksaUJBQWlCLEVBQUUsQ0FBQztvQ0FBQyxpQkFBaUIsR0FBRyxLQUFLLENBQUM7b0NBQUMsTUFBTSxNQUFNLENBQUMsS0FBSyxDQUFDLEtBQUssRUFBRSxDQUFDO2dDQUFDLENBQUM7O29DQUM1RSxNQUFNLE1BQU0sQ0FBQyxLQUFLLENBQUMsWUFBWSxFQUFFLENBQUM7Z0NBQ3ZDLFdBQVcsR0FBRyxJQUFJLENBQUM7NEJBQ3JCLENBQUM7d0JBQ0gsQ0FBQyxDQUFDO3FCQUNILENBQUMsQ0FBQztvQkFDSCxNQUFNLFFBQVEsR0FBRyxPQUFPLENBQUMsT0FBTyxDQUFDLENBQUMsU0FBUyxFQUFFLEVBQUUsQ0FBQyxTQUFTLENBQUMsTUFBTSxLQUFLLFVBQVUsQ0FBQyxDQUFDLENBQUMsQ0FBQyxTQUFTLENBQUMsTUFBaUIsQ0FBQyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQztvQkFDdEgsSUFBSSxRQUFRLENBQUMsTUFBTTt3QkFBRSxNQUFNLElBQUksY0FBYyxDQUFDLFFBQVEsRUFBRSx3Q0FBd0MsQ0FBQyxDQUFDO2dCQUNwRyxDQUFDLENBQUMsQ0FBQztnQkFDSCxNQUFNLE1BQU0sQ0FBQyxLQUFLLENBQUMsVUFBVSxDQUFDLEVBQUUsTUFBTSxFQUFFLFFBQVEsQ0FBQyxNQUFNLEVBQUUsQ0FBQyxDQUFDO2dCQUMzRCxRQUFRLENBQUMsVUFBVSxFQUFFLENBQUM7Z0JBQ3RCLFFBQVEsR0FBRyxJQUFJLE9BQU8sQ0FBQyxzQkFBc0IsQ0FBQyxnQkFBZ0IsQ0FBQyxFQUFFLE1BQU0sRUFBRSxNQUFNLENBQUMsTUFBTTtvQkFDcEYsb0JBQW9CLEVBQUUsTUFBTSxDQUFDLG9CQUFvQixFQUFFLGFBQWEsRUFBRSxNQUFNLENBQUMsYUFBYTtvQkFDdEYsWUFBWSxFQUFFLEdBQUcsRUFBRSxDQUFDLFVBQVUsQ0FBQyxTQUFTLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSxDQUFDLG9CQUFvQjtvQkFDM0YsRUFBRSxFQUFFLE1BQU0sQ0FBQyxvQkFBb0IsRUFBRSxTQUFTLEVBQUUsTUFBTSxDQUFDLFNBQVMsRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLENBQUMsZ0JBQWdCO29CQUN2RyxvQkFBb0IsRUFBRSxNQUFNLENBQUMsb0JBQW9CLEVBQUUsQ0FBQyxDQUFDO2dCQUN2RCxNQUFNLFFBQVEsQ0FBQyxZQUFZLENBQUMsRUFBRSxNQUFNLEVBQUUsUUFBUSxDQUFDLE1BQU0sRUFBRSxDQUFDLENBQUM7Z0JBQ3pELFFBQVEsQ0FBQyxVQUFVLEVBQUUsQ0FBQztnQkFDdEIsTUFBTSxNQUFNLENBQUMsS0FBSyxDQUFDLE1BQU0sQ0FBQyxxQkFBcUIsQ0FBQyxNQUFNLENBQUMsRUFBRSxVQUFVLENBQUMsQ0FBQztnQkFDckUsUUFBUSxDQUFDLFVBQVUsRUFBRSxDQUFDO2dCQUN0QixPQUFPLEVBQUUsSUFBSSxFQUFFLE1BQU0sRUFBRSxLQUFLLEVBQUUsdURBQXVELEVBQUUsTUFBTSxFQUFFLENBQUM7WUFDbEcsQ0FBQztZQUFDLE1BQU0sQ0FBQztnQkFBQyxPQUFPLEVBQUUsSUFBSSxFQUFFLE9BQU8sRUFBRSxLQUFLLEVBQUUsNEVBQTRFLEVBQUUsQ0FBQztZQUFDLENBQUM7UUFDNUgsQ0FBQyxDQUFDLENBQUMsS0FBSyxDQUFDLENBQUMsUUFBaUIsRUFBb0MsRUFBRTtZQUMvRCxJQUFJLFFBQVEsWUFBWSxjQUFjO2dCQUFFLE1BQU0sUUFBUSxDQUFDO1lBQ3ZELE9BQU8sRUFBRSxJQUFJLEVBQUUsT0FBTyxFQUFFLEtBQUssRUFBRSwrQ0FBK0MsRUFBRSxDQUFDO1FBQ25GLENBQUMsQ0FBQyxDQUFDO0lBQ0wsQ0FBQztDQUNGIn0=

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

@@ -1,8 +1,9 @@
 import { BaseIntegration } from '../../core/classes.baseintegration.js';
 import type { IIntegrationRuntime, IIntegrationSetupContext } from '../../core/types.js';
 import { NanoleafConfigFlow } from './nanoleaf.classes.configflow.js';
-import type { INanoleafConfig } from './nanoleaf.types.js';
+import type { INanoleafConfig, INanoleafIntegrationOptions } from './nanoleaf.types.js';
 export declare class NanoleafIntegration extends BaseIntegration<INanoleafConfig> {
+    #private;
     readonly domain = "nanoleaf";
     readonly displayName = "Nanoleaf";
     readonly status: 'control-runtime';
@@ -10,19 +11,18 @@ export declare class NanoleafIntegration extends BaseIntegration<INanoleafConfig
     readonly configFlow: NanoleafConfigFlow;
     readonly metadata: {
         source: string;
-        upstreamPath: string;
         upstreamDomain: string;
         integrationType: string;
         iotClass: string;
-        documentation: string;
-        requirements: string[];
-        codeowners: string[];
-        zeroconf: string[];
-        ssdp: string[];
-        homekitModels: string[];
+        localApi: {
+            implemented: string[];
+            explicitUnsupported: string[];
+        };
     };
+    constructor(ownerArg?: INanoleafIntegrationOptions);
     setup(configArg: INanoleafConfig, contextArg: IIntegrationSetupContext): Promise<IIntegrationRuntime>;
     destroy(): Promise<void>;
+    retryCleanup(): Promise<void>;
 }
 export declare class HomeAssistantNanoleafIntegration extends NanoleafIntegration {
 }