@smarthome.exchange/integrations 0.2.0 → 2.0.0

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

@@ -1,63 +1,162 @@
+import * as plugins from '../../plugins.js';
 import { BaseIntegration } from '../../core/classes.baseintegration.js';
+import { NoSqlConfigStore } from '../../core/classes.configstore.js';
 import { TplinkClient } from './tplink.classes.client.js';
 import { TplinkConfigFlow } from './tplink.classes.configflow.js';
 import { createTplinkDiscoveryDescriptor } from './tplink.discovery.js';
-import { TplinkMapper } from './tplink.mapper.js';
+import { TplinkNativeMapper } from './tplink.native.mapper.js';
+import { normalizeTplinkNativeConfig } from './tplink.validation.js';
 export class TplinkIntegration extends BaseIntegration {
     domain = 'tplink';
-    displayName = 'TP-Link Smart Home';
+    displayName = 'TP-Link legacy Kasa';
     status = 'control-runtime';
     discoveryDescriptor = createTplinkDiscoveryDescriptor();
     configFlow = new TplinkConfigFlow();
     metadata = {
-        source: 'home-assistant/core',
-        upstreamPath: 'homeassistant/components/tplink',
-        upstreamDomain: 'tplink',
-        documentation: 'https://www.home-assistant.io/integrations/tplink',
-        integrationType: 'device',
-        iotClass: 'local_polling',
-        qualityScale: 'platinum',
-        requirements: ['python-kasa[speedups]==0.10.2'],
-        dependencies: ['network', 'ffmpeg', 'stream'],
-        afterDependencies: [],
-        codeowners: ['@rytilahti', '@bdraco', '@sdb9696'],
-        dhcpDiscoveryPorts: [9999, 20002],
-        liveLocalWritesImplemented: false,
+        source: '@ecobridge.xyz/devicemanager', documentation: 'https://www.home-assistant.io/integrations/tplink',
+        integrationType: 'device', iotClass: 'local_polling', protocol: 'legacy-kasa',
+        supportedCapabilities: ['single-relay'], liveLocalWritesImplemented: true,
     };
+    #clients = new Set();
+    #runtimes = new Set();
+    #destroyed = false;
+    #destroy;
     async setup(configArg, contextArg) {
-        void contextArg;
-        return new TplinkRuntime(new TplinkClient(configArg));
+        if (this.#destroyed)
+            throw new Error('TP-Link integration is destroyed.');
+        const config = normalizeTplinkNativeConfig(configArg);
+        if (contextArg.configStore !== undefined) {
+            if (!(contextArg.configStore instanceof NoSqlConfigStore))
+                throw new TypeError('TP-Link config store must be an encrypted NoSqlConfigStore.');
+            const scope = contextArg.configStore.getScope();
+            if (scope.homeId !== config.homeId || scope.integrationDomain !== this.domain)
+                throw new TypeError('TP-Link config store scope does not match the configured home and domain.');
+        }
+        const client = new TplinkClient(config, contextArg.abortSignal);
+        this.#clients.add(client);
+        try {
+            const identity = await client.getSnapshot(contextArg.abortSignal);
+            if (this.#destroyed || contextArg.abortSignal?.aborted)
+                throw new Error('TP-Link setup was canceled.');
+            const runtime = new TplinkRuntime(client, identity, () => { this.#runtimes.delete(runtime); });
+            this.#runtimes.add(runtime);
+            this.#clients.delete(client);
+            return runtime;
+        }
+        catch (errorArg) {
+            try {
+                await client.destroy();
+            }
+            catch (cleanupErrorArg) {
+                throw new AggregateError([errorArg, cleanupErrorArg], 'TP-Link setup and cleanup failed.');
+            }
+            finally {
+                this.#clients.delete(client);
+            }
+            throw errorArg;
+        }
+    }
+    destroy() {
+        if (!this.#destroy) {
+            this.#destroyed = true;
+            this.#destroy = Promise.allSettled([
+                ...[...this.#runtimes].map((runtimeArg) => runtimeArg.destroy()),
+                ...[...this.#clients].map((clientArg) => clientArg.destroy()),
+            ]).then((resultsArg) => {
+                this.#clients.clear();
+                this.#runtimes.clear();
+                const errors = resultsArg.flatMap((resultArg) => resultArg.status === 'rejected' ? [resultArg.reason] : []);
+                if (errors.length)
+                    throw new AggregateError(errors, 'TP-Link integration cleanup failed.');
+            });
+        }
+        return this.#destroy;
     }
-    async destroy() { }
 }
 export class HomeAssistantTplinkIntegration extends TplinkIntegration {
 }
 class TplinkRuntime {
-    client;
     domain = 'tplink';
-    constructor(client) {
-        this.client = client;
-    }
-    async devices() {
-        return TplinkMapper.toDevices(await this.client.getSnapshot());
+    #client;
+    #identity;
+    #release;
+    #subscriptions = new Set();
+    #destroy;
+    constructor(clientArg, identityArg, releaseArg) {
+        this.#client = clientArg;
+        this.#identity = identityArg;
+        this.#release = releaseArg;
     }
-    async entities() {
-        return TplinkMapper.toEntities(await this.client.getSnapshot());
+    isHealthy() { return this.#client.isHealthy(); }
+    async devices(abortSignalArg) {
+        return TplinkNativeMapper.toDevices(await this.#client.getSnapshot(abortSignalArg));
     }
-    async subscribe(handlerArg) {
-        const unsubscribe = this.client.onEvent((eventArg) => handlerArg(TplinkMapper.toIntegrationEvent(eventArg)));
-        await this.client.getSnapshot();
-        return async () => unsubscribe();
+    async entities() { return TplinkNativeMapper.toEntities(await this.#client.getSnapshot()); }
+    async subscribe(handlerArg, abortSignalArg) {
+        abortSignalArg?.throwIfAborted();
+        const unsubscribe = this.#client.onEvent((eventArg) => handlerArg({
+            type: 'state_changed', integrationDomain: this.domain, deviceId: TplinkNativeMapper.deviceId(eventArg.snapshot),
+            entityId: TplinkNativeMapper.entityId(eventArg.snapshot), timestamp: Date.parse(eventArg.snapshot.observedAt),
+            data: { entity: TplinkNativeMapper.toEntities(eventArg.snapshot)[0] },
+        }));
+        const release = () => {
+            unsubscribe();
+            abortSignalArg?.removeEventListener('abort', release);
+            this.#subscriptions.delete(release);
+        };
+        this.#subscriptions.add(release);
+        abortSignalArg?.addEventListener('abort', release, { once: true });
+        if (abortSignalArg?.aborted)
+            release();
+        try {
+            await this.#client.getSnapshot(abortSignalArg);
+        }
+        catch (errorArg) {
+            release();
+            throw errorArg;
+        }
+        return async () => { release(); };
     }
     async callService(requestArg) {
-        const command = TplinkMapper.commandForService(await this.client.getSnapshot(), requestArg);
-        if (!command) {
-            return { success: false, error: `Unsupported TP-Link service mapping: ${requestArg.domain}.${requestArg.service}` };
+        let power;
+        try {
+            power = TplinkNativeMapper.powerForService(this.#identity, requestArg);
         }
-        return this.client.sendCommand(command);
+        catch (errorArg) {
+            return this.admissionFailure(errorArg);
+        }
+        return this.writeResult(await this.#client.setPower(power));
+    }
+    async writeFeature(requestArg, abortSignalArg) {
+        let power;
+        try {
+            power = TplinkNativeMapper.powerForFeature(this.#identity, requestArg);
+        }
+        catch (errorArg) {
+            return this.admissionFailure(errorArg);
+        }
+        return this.writeResult(await this.#client.setPower(power, abortSignalArg));
+    }
+    destroy() {
+        if (!this.#destroy) {
+            for (const release of [...this.#subscriptions])
+                release();
+            this.#destroy = this.#client.destroy().finally(() => this.#release());
+        }
+        return this.#destroy;
+    }
+    writeResult(dataArg) {
+        return {
+            success: dataArg.outcome === 'accepted', data: dataArg,
+            error: dataArg.outcome === 'accepted' ? undefined : dataArg.outcome === 'indeterminate' ?
+                'TP-Link relay execution is indeterminate; do not retry automatically.' : 'TP-Link relay write was not accepted.',
+        };
     }
-    async destroy() {
-        await this.client.destroy();
+    admissionFailure(errorArg) {
+        return {
+            success: false, error: errorArg instanceof Error ? errorArg.message : 'TP-Link write admission failed.',
+            data: { outcome: 'not-sent', physicalStateConfirmed: false, deviceId: this.#identity.deviceId },
+        };
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tplink.classes.integration.js","sourceRoot":"","sources":["../../../ts/integrations/tplink/tplink.classes.integration.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,kBAAkB,CAAC;AAC5C,OAAO,EAAE,eAAe,EAAE,MAAM,uCAAuC,CAAC;AACxE,OAAO,EAAE,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AAErE,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAClE,OAAO,EAAE,+BAA+B,EAAE,MAAM,uBAAuB,CAAC;AACxE,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAE/D,OAAO,EAAE,2BAA2B,EAAE,MAAM,wBAAwB,CAAC;AAErE,MAAM,OAAO,iBAAkB,SAAQ,eAAoC;IACzD,MAAM,GAAG,QAAQ,CAAC;IAClB,WAAW,GAAG,qBAAqB,CAAC;IACpC,MAAM,GAAG,iBAA0B,CAAC;IACpC,mBAAmB,GAAG,+BAA+B,EAAE,CAAC;IACxD,UAAU,GAAG,IAAI,gBAAgB,EAAE,CAAC;IACpC,QAAQ,GAAG;QACzB,MAAM,EAAE,8BAA8B,EAAE,aAAa,EAAE,mDAAmD;QAC1G,eAAe,EAAE,QAAQ,EAAE,QAAQ,EAAE,eAAe,EAAE,QAAQ,EAAE,aAAa;QAC7E,qBAAqB,EAAE,CAAC,cAAc,CAAC,EAAE,0BAA0B,EAAE,IAAI;KAC1E,CAAC;IACO,QAAQ,GAAG,IAAI,GAAG,EAAgB,CAAC;IACnC,SAAS,GAAG,IAAI,GAAG,EAAiB,CAAC;IAC9C,UAAU,GAAG,KAAK,CAAC;IACnB,QAAQ,CAAiB;IAElB,KAAK,CAAC,KAAK,CAAC,SAA8B,EAAE,UAAoC;QACrF,IAAI,IAAI,CAAC,UAAU;YAAE,MAAM,IAAI,KAAK,CAAC,mCAAmC,CAAC,CAAC;QAC1E,MAAM,MAAM,GAAG,2BAA2B,CAAC,SAAS,CAAC,CAAC;QACtD,IAAI,UAAU,CAAC,WAAW,KAAK,SAAS,EAAE,CAAC;YACzC,IAAI,CAAC,CAAC,UAAU,CAAC,WAAW,YAAY,gBAAgB,CAAC;gBAAE,MAAM,IAAI,SAAS,CAAC,6DAA6D,CAAC,CAAC;YAC9I,MAAM,KAAK,GAAG,UAAU,CAAC,WAAW,CAAC,QAAQ,EAAE,CAAC;YAChD,IAAI,KAAK,CAAC,MAAM,KAAK,MAAM,CAAC,MAAM,IAAI,KAAK,CAAC,iBAAiB,KAAK,IAAI,CAAC,MAAM;gBAAE,MAAM,IAAI,SAAS,CAAC,2EAA2E,CAAC,CAAC;QAClL,CAAC;QACD,MAAM,MAAM,GAAG,IAAI,YAAY,CAAC,MAAM,EAAE,UAAU,CAAC,WAAW,CAAC,CAAC;QAChE,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QAC1B,IAAI,CAAC;YACH,MAAM,QAAQ,GAAG,MAAM,MAAM,CAAC,WAAW,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC;YAClE,IAAI,IAAI,CAAC,UAAU,IAAI,UAAU,CAAC,WAAW,EAAE,OAAO;gBAAE,MAAM,IAAI,KAAK,CAAC,6BAA6B,CAAC,CAAC;YACvG,MAAM,OAAO,GAAG,IAAI,aAAa,CAAC,MAAM,EAAE,QAAQ,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAC/F,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;YAC5B,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;YAC7B,OAAO,OAAO,CAAC;QACjB,CAAC;QAAC,OAAO,QAAQ,EAAE,CAAC;YAClB,IAAI,CAAC;gBAAC,MAAM,MAAM,CAAC,OAAO,EAAE,CAAC;YAAC,CAAC;YAC/B,OAAO,eAAe,EAAE,CAAC;gBAAC,MAAM,IAAI,cAAc,CAAC,CAAC,QAAQ,EAAE,eAAe,CAAC,EAAE,mCAAmC,CAAC,CAAC;YAAC,CAAC;oBAC/G,CAAC;gBAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;YAAC,CAAC;YACzC,MAAM,QAAQ,CAAC;QACjB,CAAC;IACH,CAAC;IAEM,OAAO;QACZ,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC;YACnB,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;YACvB,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;gBACjC,GAAG,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,GAAG,CAAC,CAAC,UAAU,EAAE,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,CAAC;gBAChE,GAAG,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,CAAC,OAAO,EAAE,CAAC;aAC9D,CAAC,CAAC,IAAI,CAAC,CAAC,UAAU,EAAE,EAAE;gBACrB,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;gBACtB,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,CAAC;gBACvB,MAAM,MAAM,GAAG,UAAU,CAAC,OAAO,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,CAAC,MAAM,KAAK,UAAU,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,MAAiB,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;gBACvH,IAAI,MAAM,CAAC,MAAM;oBAAE,MAAM,IAAI,cAAc,CAAC,MAAM,EAAE,qCAAqC,CAAC,CAAC;YAC7F,CAAC,CAAC,CAAC;QACL,CAAC;QACD,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;CACF;AAED,MAAM,OAAO,8BAA+B,SAAQ,iBAAiB;CAAG;AAExE,MAAM,aAAa;IACD,MAAM,GAAG,QAAQ,CAAC;IACzB,OAAO,CAAe;IACtB,SAAS,CAAwB;IACjC,QAAQ,CAAa;IACrB,cAAc,GAAG,IAAI,GAAG,EAAc,CAAC;IAChD,QAAQ,CAAiB;IAEzB,YAAY,SAAuB,EAAE,WAAkC,EAAE,UAAsB;QAC7F,IAAI,CAAC,OAAO,GAAG,SAAS,CAAC;QACzB,IAAI,CAAC,SAAS,GAAG,WAAW,CAAC;QAC7B,IAAI,CAAC,QAAQ,GAAG,UAAU,CAAC;IAC7B,CAAC;IAEM,SAAS,KAAc,OAAO,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC;IAEzD,KAAK,CAAC,OAAO,CAAC,cAA4B;QAC/C,OAAO,kBAAkB,CAAC,SAAS,CAAC,MAAM,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,cAAc,CAAC,CAAC,CAAC;IACtF,CAAC;IAEM,KAAK,CAAC,QAAQ,KAAoC,OAAO,kBAAkB,CAAC,UAAU,CAAC,MAAM,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,CAAC;IAE3H,KAAK,CAAC,SAAS,CAAC,UAAiD,EAAE,cAA4B;QACpG,cAAc,EAAE,cAAc,EAAE,CAAC;QACjC,MAAM,WAAW,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,UAAU,CAAC;YAChE,IAAI,EAAE,eAAe,EAAE,iBAAiB,EAAE,IAAI,CAAC,MAAM,EAAE,QAAQ,EAAE,kBAAkB,CAAC,QAAQ,CAAC,QAAQ,CAAC,QAAQ,CAAC;YAC/G,QAAQ,EAAE,kBAAkB,CAAC,QAAQ,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,EAAE,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,QAAQ,CAAC,UAAU,CAAC;YAC7G,IAAI,EAAE,EAAE,MAAM,EAAE,kBAAkB,CAAC,UAAU,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,EAAE;SACtE,CAAC,CAAC,CAAC;QACJ,MAAM,OAAO,GAAG,GAAS,EAAE;YACzB,WAAW,EAAE,CAAC;YACd,cAAc,EAAE,mBAAmB,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;YACtD,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QACtC,CAAC,CAAC;QACF,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;QACjC,cAAc,EAAE,gBAAgB,CAAC,OAAO,EAAE,OAAO,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;QACnE,IAAI,cAAc,EAAE,OAAO;YAAE,OAAO,EAAE,CAAC;QACvC,IAAI,CAAC;YAAC,MAAM,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,cAAc,CAAC,CAAC;QAAC,CAAC;QACvD,OAAO,QAAQ,EAAE,CAAC;YAAC,OAAO,EAAE,CAAC;YAAC,MAAM,QAAQ,CAAC;QAAC,CAAC;QAC/C,OAAO,KAAK,IAAI,EAAE,GAAG,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC;IACpC,CAAC;IAEM,KAAK,CAAC,WAAW,CAAC,UAA+B;QACtD,IAAI,KAAc,CAAC;QACnB,IAAI,CAAC;YAAC,KAAK,GAAG,kBAAkB,CAAC,eAAe,CAAC,IAAI,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC;QAAC,CAAC;QAC/E,OAAO,QAAQ,EAAE,CAAC;YAAC,OAAO,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,CAAC;QAAC,CAAC;QAC5D,OAAO,IAAI,CAAC,WAAW,CAAC,MAAM,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC;IAC9D,CAAC;IAEM,KAAK,CAAC,YAAY,CAAC,UAAsC,EAAE,cAA4B;QAC5F,IAAI,KAAc,CAAC;QACnB,IAAI,CAAC;YAAC,KAAK,GAAG,kBAAkB,CAAC,eAAe,CAAC,IAAI,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC;QAAC,CAAC;QAC/E,OAAO,QAAQ,EAAE,CAAC;YAAC,OAAO,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,CAAC;QAAC,CAAC;QAC5D,OAAO,IAAI,CAAC,WAAW,CAAC,MAAM,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAC,CAAC,CAAC;IAC9E,CAAC;IAEM,OAAO;QACZ,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC;YACnB,KAAK,MAAM,OAAO,IAAI,CAAC,GAAG,IAAI,CAAC,cAAc,CAAC;gBAAE,OAAO,EAAE,CAAC;YAC1D,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC;QACxE,CAAC;QACD,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;IAEO,WAAW,CAAC,OAAiC;QACnD,OAAO;YACL,OAAO,EAAE,OAAO,CAAC,OAAO,KAAK,UAAU,EAAE,IAAI,EAAE,OAAO;YACtD,KAAK,EAAE,OAAO,CAAC,OAAO,KAAK,UAAU,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,KAAK,eAAe,CAAC,CAAC;gBACvF,uEAAuE,CAAC,CAAC,CAAC,uCAAuC;SACpH,CAAC;IACJ,CAAC;IAEO,gBAAgB,CAAC,QAAiB;QACxC,OAAO;YACL,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,QAAQ,YAAY,KAAK,CAAC,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,iCAAiC;YACvG,IAAI,EAAE,EAAE,OAAO,EAAE,UAAU,EAAE,sBAAsB,EAAE,KAAK,EAAE,QAAQ,EAAE,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE;SAChG,CAAC;IACJ,CAAC;CACF"}

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

@@ -2,29 +2,26 @@ import { DiscoveryDescriptor } from '../../core/classes.discoverydescriptor.js';
 import type { IDiscoveryCandidate, IDiscoveryContext, IDiscoveryMatch, IDiscoveryMatcher, IDiscoveryValidator } from '../../core/types.js';
 import type { ITplinkDhcpRecord, ITplinkManualDiscoveryRecord, ITplinkMdnsRecord } from './tplink.types.js';
 export declare class TplinkMdnsMatcher implements IDiscoveryMatcher<ITplinkMdnsRecord> {
-    id: string;
-    source: "mdns";
-    description: string;
+    readonly id = "tplink-mdns-match";
+    readonly source: 'mdns';
+    readonly description = "Recognize TP-Link advertisements as hints that require an actual legacy relay query.";
     matches(recordArg: ITplinkMdnsRecord, contextArg?: IDiscoveryContext): Promise<IDiscoveryMatch>;
-    private txt;
 }
 export declare class TplinkDhcpMatcher implements IDiscoveryMatcher<ITplinkDhcpRecord> {
-    id: string;
-    source: "dhcp";
-    description: string;
+    readonly id = "tplink-dhcp-match";
+    readonly source: 'dhcp';
+    readonly description = "Recognize possible legacy Kasa DHCP names without treating them as identity proof.";
     matches(recordArg: ITplinkDhcpRecord, contextArg?: IDiscoveryContext): Promise<IDiscoveryMatch>;
-    private stringValue;
 }
 export declare class TplinkManualMatcher implements IDiscoveryMatcher<ITplinkManualDiscoveryRecord> {
-    id: string;
-    source: "manual";
-    description: string;
+    readonly id = "tplink-manual-match";
+    readonly source: 'manual';
+    readonly description = "Admit explicit IP candidates for legacy Kasa verification; snapshots and credentials are unsupported.";
     matches(inputArg: ITplinkManualDiscoveryRecord, contextArg?: IDiscoveryContext): Promise<IDiscoveryMatch>;
 }
 export declare class TplinkCandidateValidator implements IDiscoveryValidator {
-    id: string;
-    description: string;
+    readonly id = "tplink-candidate-validator";
+    readonly description = "Verify observed legacy single-relay identity over the owning bounded TCP API.";
     validate(candidateArg: IDiscoveryCandidate, contextArg?: IDiscoveryContext): Promise<IDiscoveryMatch>;
-    private stringValue;
 }
 export declare const createTplinkDiscoveryDescriptor: () => DiscoveryDescriptor;