@matter/general 0.16.8-alpha.0-20260125-38e62bc3e → 0.16.8-alpha.0-20260127-65e1b40e2

package/dist/esm/net/dns-sd/IpServiceStatus.js

@@ -0,0 +1,171 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Diagnostic } from "#log/Diagnostic.js";
+import { Logger } from "#log/Logger.js";
+import { AbortedError } from "#MatterError.js";
+import { ServerAddress } from "#net/ServerAddress.js";
+import { Time } from "#time/Time.js";
+import { Abort } from "#util/Abort.js";
+import { asError } from "#util/Error.js";
+import { BasicSet } from "#util/Set.js";
+import { IpServiceResolution } from "./IpServiceResolution.js";
+const logger = Logger.get("IpServiceStatus");
+class IpServiceStatus {
+  #service;
+  #isReachable = false;
+  #connecting = new BasicSet();
+  #resolveAbort;
+  #resolving;
+  #connectionInitiatedAt;
+  #lastReceiptAt;
+  constructor(service) {
+    this.#service = service;
+  }
+  async close() {
+    this.#stopResolving();
+    if (this.#resolving) {
+      await this.#resolving;
+    }
+  }
+  /**
+   * Is the service actively connecting?
+   *
+   * This is true so long as a promise passed to {@link connecting} is unresolved.
+   */
+  get isConnecting() {
+    return this.#connecting.size > 0;
+  }
+  /**
+   * Is the service currently reachable?
+   *
+   * This value is writable.  If you set {@link isReachable} to false and {@link isConnecting} is true, the service
+   * enters discovery mode and begins active solicitation so long as neither condition changes.
+   *
+   * The service sets {@link isReachable} to true automatically if:
+   *
+   * - It discovers a new (previously unknown) address, or
+   *
+   * - The input promise to {@link connecting} resolves to true
+   *
+   * The service sets {@link isReachable} to false automatically if the input promise to {@link connecting} resolves
+   * to false.
+   */
+  get isReachable() {
+    return this.#isReachable;
+  }
+  /**
+   * Are we actively performing MDNS discovery for the service?
+   */
+  get isResolving() {
+    return this.#resolving !== void 0;
+  }
+  set isReachable(isReachable) {
+    if (this.#isReachable === isReachable) {
+      return;
+    }
+    this.#isReachable = isReachable;
+    if (isReachable) {
+      this.#maybeStopResolving();
+    } else {
+      this.#maybeStartResolving();
+    }
+  }
+  get lastReceiptAt() {
+    return this.#lastReceiptAt;
+  }
+  set lastReceiptAt(time) {
+    this.#lastReceiptAt = time;
+  }
+  get connectionInitiatedAt() {
+    return this.#connectionInitiatedAt;
+  }
+  /**
+   * Register a new connection attempt.
+   *
+   * If {@link result} resolves as true the service is marked as reachable.  If {@link result} resolves as false
+   * reachability is not modified.
+   *
+   * If {@link result} throws an error other than {@link AbortedError}, the service is marked as unreachable and if
+   * the error logged.
+   *
+   * {@link isConnecting} will be true until {@link result} resolves.
+   */
+  connecting(result) {
+    logger.debug(this.#service.via, "Connecting");
+    result.then(
+      (returned) => {
+        this.#connecting.delete(result);
+        if (!this.#connecting.size) {
+          this.#connectionInitiatedAt = void 0;
+        }
+        if (returned) {
+          this.isReachable = true;
+          logger.info(this.#service.via, "Connected");
+        } else {
+          logger.debug(this.#service.via, "Connect attempt aborted");
+        }
+        this.#maybeStopResolving();
+      },
+      (error) => {
+        this.#connecting.delete(result);
+        if (!(error instanceof AbortedError)) {
+          return;
+        }
+        logger.error(this.#service.via, "Connection error:", asError(error));
+        this.#isReachable = false;
+        this.#maybeStartResolving();
+      }
+    );
+    this.#connectionInitiatedAt = Time.nowMs;
+    this.#connecting.add(result);
+    this.#maybeStartResolving();
+  }
+  #maybeStartResolving() {
+    if (this.#isReachable || !this.isConnecting || this.#resolveAbort) {
+      return;
+    }
+    const numAddresses = this.#service.addresses.size;
+    let why;
+    switch (numAddresses) {
+      case 0:
+        why = "need address";
+        break;
+      case 1:
+        why = "address is unreachable";
+        break;
+      default:
+        why = `${numAddresses} known addresses are unreachable`;
+    }
+    logger.info(this.#service.via, "Resolving", Diagnostic.weak(`(${why})`));
+    this.#resolveAbort = new Abort();
+    this.#resolving = IpServiceResolution(this.#service, this.#resolveAbort).finally(() => {
+      if (this.#resolveAbort?.aborted === false) {
+        const addresses = [...this.#service.addresses].map(ServerAddress.urlFor);
+        logger.debug(this.#service.via, `Resolved as ${addresses.join(", ")}`);
+      }
+      this.#resolveAbort?.close();
+      this.#resolveAbort = void 0;
+      this.#resolving = void 0;
+    });
+  }
+  #maybeStopResolving() {
+    if (!this.#isReachable || this.isConnecting || !this.#resolveAbort) {
+      return;
+    }
+    this.#stopResolving();
+  }
+  #stopResolving() {
+    if (!this.#resolveAbort) {
+      return;
+    }
+    this.#resolveAbort();
+    logger.debug(this.#service.via, "Stopped resolving");
+  }
+}
+export {
+  IpServiceStatus
+};
+//# sourceMappingURL=IpServiceStatus.js.map

package/dist/esm/net/dns-sd/IpServiceStatus.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/net/dns-sd/IpServiceStatus.ts"],
+  "mappings": "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",
+  "names": []
+}

package/dist/esm/net/dns-sd/index.d.ts

@@ -3,5 +3,11 @@
  * Copyright 2022-2026 Matter.js Authors
  * SPDX-License-Identifier: Apache-2.0
  */
+export * from "./DnssdName.js";
+export * from "./DnssdNames.js";
+export * from "./DnssdSolicitor.js";
+export * from "./IpService.js";
+export * from "./IpServiceResolution.js";
+export * from "./IpServiceStatus.js";
 export * from "./MdnsSocket.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/esm/net/dns-sd/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/net/dns-sd/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,iBAAiB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/net/dns-sd/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,qBAAqB,CAAC;AACpC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,0BAA0B,CAAC;AACzC,cAAc,sBAAsB,CAAC;AACrC,cAAc,iBAAiB,CAAC"}

package/dist/esm/net/dns-sd/index.js

@@ -3,5 +3,11 @@
  * Copyright 2022-2026 Matter.js Authors
  * SPDX-License-Identifier: Apache-2.0
  */
+export * from "./DnssdName.js";
+export * from "./DnssdNames.js";
+export * from "./DnssdSolicitor.js";
+export * from "./IpService.js";
+export * from "./IpServiceResolution.js";
+export * from "./IpServiceStatus.js";
 export * from "./MdnsSocket.js";
 //# sourceMappingURL=index.js.map

package/dist/esm/net/dns-sd/index.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
   "sources": ["../../../../src/net/dns-sd/index.ts"],
-  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,cAAc;",
+  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;",
   "names": []
 }

package/dist/esm/net/udp/UdpInterface.js

@@ -65,7 +65,7 @@ class UdpConnection {
     return this.#server.send(this.#peerAddress, this.#peerPort, data);
   }
   get name() {
-    return `${this.type}://[${this.#peerAddress}]:${this.#peerPort}`;
+    return `${this.type}://${this.#peerAddress.includes(":") ? `[${this.#peerAddress}]` : this.#peerAddress}:${this.#peerPort}`;
   }
   get networkAddress() {
     return { type: "udp", ip: this.#peerAddress, port: this.#peerPort };

package/dist/esm/net/udp/UdpInterface.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
   "sources": ["../../../../src/net/udp/UdpInterface.ts"],
-  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,SAAkB,mBAAqC;AAEvD,SAAkB,oBAAoB;AAK/B,MAAM,aAAgD;AAAA,EAChD;AAAA,EAET,aAAa,OAAO,SAAkB,MAAuB,MAAe,MAAe,cAAuB;AAC9G,WAAO,IAAI;AAAA,MACP,MAAM,QAAQ,iBAAiB,EAAE,eAAe,MAAM,MAAM,cAAc,kBAAkB,KAAK,CAAC;AAAA,IACtG;AAAA,EACJ;AAAA,EAEA,YAAY,QAAoB;AAC5B,SAAK,UAAU;AAAA,EACnB;AAAA,EAEA,IAAc,SAAS;AACnB,WAAO,KAAK;AAAA,EAChB;AAAA,EAEA,SAAS,MAAmB,SAAiB;AACzC,WAAO,KAAK,QAAQ,SAAS,MAAM,OAAO;AAAA,EAC9C;AAAA,EAEA,MAAM,YAAY,SAAwB;AACtC,QAAI,QAAQ,SAAS,OAAO;AACxB,YAAM,IAAI,aAAa,4BAA4B,QAAQ,IAAI,EAAE;AAAA,IACrE;AACA,UAAM,EAAE,IAAI,KAAK,IAAI;AACrB,WAAO,QAAQ,QAAQ,IAAI,cAAc,KAAK,SAAS,IAAI,IAAI,CAAC;AAAA,EACpE;AAAA,EAEA,OAAO,UAAoG;AACvG,WAAO,KAAK,QAAQ;AAAA,MAAO,CAAC,eAAe,UAAU,UAAU,SAC3D,SAAS,IAAI,cAAc,KAAK,SAAS,UAAU,QAAQ,GAAG,IAAI;AAAA,IACtE;AAAA,EACJ;AAAA,EAEA,IAAI,OAAO;AACP,WAAO,KAAK,QAAQ;AAAA,EACxB;AAAA,EAEA,QAAQ;AACJ,WAAO,KAAK,QAAQ,MAAM;AAAA,EAC9B;AAAA,EAEA,cAAc,SAAiB;AAC3B,WAAO,KAAK,QAAQ,cAAc,OAAO;AAAA,EAC7C;AAAA,EAEA,eAAe,SAAiB;AAC5B,WAAO,KAAK,QAAQ,eAAe,OAAO;AAAA,EAC9C;AACJ;AAEO,MAAM,cAAiD;AAAA,EACjD,aAAa;AAAA,EACb,wBAAwB;AAAA,EACxB,OAAO,YAAY;AAAA,EACnB;AAAA,EACA;AAAA,EACA;AAAA,EAET,YAAY,QAAoB,aAAqB,UAAkB;AACnE,SAAK,UAAU;AACf,SAAK,eAAe;AACpB,SAAK,YAAY;AAAA,EACrB;AAAA,EAEA,IAAI,iBAAiB;AACjB,WAAO,KAAK,QAAQ;AAAA,EACxB;AAAA,EAEA,KAAK,MAAa;AACd,WAAO,KAAK,QAAQ,KAAK,KAAK,cAAc,KAAK,WAAW,IAAI;AAAA,EACpE;AAAA,EAEA,IAAI,OAAO;AACP,WAAO,GAAG,KAAK,IAAI,OAAO,KAAK,YAAY,KAAK,KAAK,SAAS;AAAA,EAClE;AAAA,EAEA,IAAI,iBAAmC;AACnC,WAAO,EAAE,MAAM,OAAO,IAAI,KAAK,cAAc,MAAM,KAAK,UAAU;AAAA,EACtE;AAAA,EAEA,MAAM,QAAQ;AAAA,EAEd;AACJ;",
+  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,SAAkB,mBAAqC;AAEvD,SAAkB,oBAAoB;AAK/B,MAAM,aAAgD;AAAA,EAChD;AAAA,EAET,aAAa,OAAO,SAAkB,MAAuB,MAAe,MAAe,cAAuB;AAC9G,WAAO,IAAI;AAAA,MACP,MAAM,QAAQ,iBAAiB,EAAE,eAAe,MAAM,MAAM,cAAc,kBAAkB,KAAK,CAAC;AAAA,IACtG;AAAA,EACJ;AAAA,EAEA,YAAY,QAAoB;AAC5B,SAAK,UAAU;AAAA,EACnB;AAAA,EAEA,IAAc,SAAS;AACnB,WAAO,KAAK;AAAA,EAChB;AAAA,EAEA,SAAS,MAAmB,SAAiB;AACzC,WAAO,KAAK,QAAQ,SAAS,MAAM,OAAO;AAAA,EAC9C;AAAA,EAEA,MAAM,YAAY,SAAwB;AACtC,QAAI,QAAQ,SAAS,OAAO;AACxB,YAAM,IAAI,aAAa,4BAA4B,QAAQ,IAAI,EAAE;AAAA,IACrE;AACA,UAAM,EAAE,IAAI,KAAK,IAAI;AACrB,WAAO,QAAQ,QAAQ,IAAI,cAAc,KAAK,SAAS,IAAI,IAAI,CAAC;AAAA,EACpE;AAAA,EAEA,OAAO,UAAoG;AACvG,WAAO,KAAK,QAAQ;AAAA,MAAO,CAAC,eAAe,UAAU,UAAU,SAC3D,SAAS,IAAI,cAAc,KAAK,SAAS,UAAU,QAAQ,GAAG,IAAI;AAAA,IACtE;AAAA,EACJ;AAAA,EAEA,IAAI,OAAO;AACP,WAAO,KAAK,QAAQ;AAAA,EACxB;AAAA,EAEA,QAAQ;AACJ,WAAO,KAAK,QAAQ,MAAM;AAAA,EAC9B;AAAA,EAEA,cAAc,SAAiB;AAC3B,WAAO,KAAK,QAAQ,cAAc,OAAO;AAAA,EAC7C;AAAA,EAEA,eAAe,SAAiB;AAC5B,WAAO,KAAK,QAAQ,eAAe,OAAO;AAAA,EAC9C;AACJ;AAEO,MAAM,cAAiD;AAAA,EACjD,aAAa;AAAA,EACb,wBAAwB;AAAA,EACxB,OAAO,YAAY;AAAA,EACnB;AAAA,EACA;AAAA,EACA;AAAA,EAET,YAAY,QAAoB,aAAqB,UAAkB;AACnE,SAAK,UAAU;AACf,SAAK,eAAe;AACpB,SAAK,YAAY;AAAA,EACrB;AAAA,EAEA,IAAI,iBAAiB;AACjB,WAAO,KAAK,QAAQ;AAAA,EACxB;AAAA,EAEA,KAAK,MAAa;AACd,WAAO,KAAK,QAAQ,KAAK,KAAK,cAAc,KAAK,WAAW,IAAI;AAAA,EACpE;AAAA,EAEA,IAAI,OAAO;AACP,WAAO,GAAG,KAAK,IAAI,MAAM,KAAK,aAAa,SAAS,GAAG,IAAI,IAAI,KAAK,YAAY,MAAM,KAAK,YAAY,IAAI,KAAK,SAAS;AAAA,EAC7H;AAAA,EAEA,IAAI,iBAAmC;AACnC,WAAO,EAAE,MAAM,OAAO,IAAI,KAAK,cAAc,MAAM,KAAK,UAAU;AAAA,EACtE;AAAA,EAEA,MAAM,QAAQ;AAAA,EAEd;AACJ;",
   "names": []
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@matter/general",
-    "version": "0.16.8-alpha.0-20260125-38e62bc3e",
+    "version": "0.16.8-alpha.0-20260127-65e1b40e2",
     "description": "Non-Matter support for Matter.js",
     "keywords": [
         "iot",
@@ -36,7 +36,7 @@
         "@noble/curves": "^2.0.1"
     },
     "devDependencies": {
-        "@matter/testing": "0.16.8-alpha.0-20260125-38e62bc3e"
+        "@matter/testing": "0.16.8-alpha.0-20260127-65e1b40e2"
     },
     "files": [
         "dist/**/*",

package/src/net/ServerAddress.ts

@@ -78,7 +78,8 @@ export namespace ServerAddress {
         switch (address.type) {
             case "udp":
             case "tcp":
-                return `${address.type}://${address.ip}:${address.port}`;
+                const ip = address.ip;
+                return `${address.type}://${ip.includes(":") ? `[${ip}]` : ip}:${address.port}`;
 
             case "ble":
                 return `ble://${address.peripheralAddress}`;

package/src/net/dns-sd/DnssdName.ts

@@ -0,0 +1,252 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { DnsRecord, DnsRecordType, SrvRecordValue } from "#codec/DnsCodec.js";
+import { Logger } from "#log/Logger.js";
+import { Time } from "#time/Time.js";
+import type { Timestamp } from "#time/Timestamp.js";
+import { AsyncObserver, BasicObservable } from "#util/Observable.js";
+import { MaybePromise } from "#util/Promises.js";
+import type { DnssdNames } from "./DnssdNames.js";
+
+const logger = Logger.get("DnssdName");
+
+/**
+ * Manages records associated with a single DNS-SD qname.
+ *
+ * Every DNS-SD qname of interest has a 1:1 relationship with a single instance of this class in the context of a
+ * {@link DnssdNames}.  We therefore can use the qname or {@link DnssdName} interchangeably.
+ *
+ * An {@link DnssdName} is created when a new name is discovered or requested by another component.  The name
+ * automatically deletes when there are no longer observers or unexpired records.
+ */
+export class DnssdName extends BasicObservable<[changes: DnssdName.Changes], MaybePromise> {
+    #context: DnssdName.Context;
+    #records = new Map<string, DnssdName.Record>();
+    #recordCount = 0;
+    #changes?: Map<string, { kind: "update" | "delete"; record: DnssdName.Record }>;
+    #notified?: Promise<void>;
+    #maybeDeleting?: Promise<void>;
+    #parameters?: Map<string, string>;
+
+    constructor(
+        readonly qname: string,
+        context: DnssdName.Context,
+    ) {
+        super(e => logger.error(`Unhandled error in observer for DNS name "${qname}":`, e));
+        this.#context = context;
+    }
+
+    override off(observer: AsyncObserver<[]>) {
+        super.off(observer);
+        this.#deleteIfUnused();
+    }
+
+    async close() {
+        if (this.#notified) {
+            await this.#notified;
+        }
+        if (this.#maybeDeleting) {
+            await this.#maybeDeleting;
+        }
+    }
+
+    get records() {
+        return this.#records.values();
+    }
+
+    get parameters() {
+        if (this.#parameters === undefined) {
+            this.#parameters = new Map();
+        }
+        return this.#parameters;
+    }
+
+    get isDiscovered() {
+        return !!this.#recordCount;
+    }
+
+    installRecord(record: DnsRecord<any>) {
+        // For TXT records, extract the standard DNS-SD k/v's
+        if (record.recordType === DnsRecordType.TXT) {
+            const entries = record.value;
+            for (const entry of entries) {
+                const pos = entry.indexOf("=");
+                if (pos === -1) {
+                    this.parameters.set(entry, "");
+                } else {
+                    this.parameters.set(entry.slice(0, pos), entry.slice(pos + 1));
+                }
+            }
+        }
+
+        const key = keyOf(record);
+        if (key === undefined) {
+            this.#deleteIfUnused();
+            return false;
+        }
+
+        const oldRecord = this.#records.get(key);
+        if (oldRecord) {
+            this.#context.unregisterForExpiration(oldRecord);
+        } else {
+            this.#recordCount++;
+        }
+
+        const recordWithExpire = { ...record, expiresAt: Time.nowMs + record.ttl } as DnssdName.Record;
+
+        this.#records.set(key, recordWithExpire);
+
+        this.#context.registerForExpiration(recordWithExpire);
+
+        this.#notify("update", key, recordWithExpire);
+    }
+
+    deleteRecord(record: DnsRecord, ifOlderThan?: Timestamp) {
+        const key = keyOf(record);
+        if (key === undefined) {
+            this.#deleteIfUnused();
+            return;
+        }
+
+        const recordWithExpire = this.#records?.get(key);
+        if (!recordWithExpire) {
+            this.#deleteIfUnused();
+            return;
+        }
+
+        if (ifOlderThan !== undefined && recordWithExpire.expiresAt - recordWithExpire.ttl >= ifOlderThan) {
+            return;
+        }
+
+        this.#records.delete(key);
+        this.#recordCount--;
+
+        this.#context.unregisterForExpiration(recordWithExpire);
+
+        if (this.#deleteIfUnused()) {
+            return;
+        }
+
+        this.#notify("delete", key, recordWithExpire);
+    }
+
+    /**
+     * Delete if unused.
+     *
+     * This is async so we assess whether deletion is appropriate after a batch of updates.
+     */
+    #deleteIfUnused() {
+        if (this.isObserved || this.isDiscovered) {
+            return false;
+        }
+
+        if (this.#maybeDeleting) {
+            return true;
+        }
+
+        const maybeDelete = async () => {
+            this.#maybeDeleting = undefined;
+
+            if (this.isObserved || this.isDiscovered) {
+                return;
+            }
+
+            this.#context.delete(this);
+        };
+
+        this.#maybeDeleting = maybeDelete();
+
+        return true;
+    }
+
+    /**
+     * Notification of observers.
+     *
+     * This is async so we coalesce changes into a single notification.
+     */
+    #notify(kind: "update" | "delete", key: string, record: DnssdName.Record) {
+        if (this.#changes === undefined) {
+            this.#changes = new Map();
+        }
+        this.#changes.set(key, { kind, record });
+
+        if (this.#notified) {
+            return;
+        }
+
+        const notify = async () => {
+            while (this.#changes?.size) {
+                const changes: DnssdName.Changes = { name: this };
+                for (const { kind, record } of this.#changes.values()) {
+                    const key: "updated" | "deleted" = `${kind}d`;
+                    const list = changes[key];
+                    if (list === undefined) {
+                        changes[key] = [record];
+                    } else {
+                        list.push(record);
+                    }
+                }
+                this.#changes.clear();
+                await this.emit(changes);
+            }
+            this.#notified = undefined;
+        };
+
+        this.#notified = notify();
+    }
+}
+
+function keyOf(record: DnsRecord): string | undefined {
+    switch (record.recordType) {
+        case DnsRecordType.A:
+        case DnsRecordType.AAAA:
+        case DnsRecordType.PTR:
+            if (typeof record.value === "string") {
+                return `${record.recordType} ${record.value}`;
+            }
+            break;
+
+        case DnsRecordType.SRV:
+            if (typeof record.value === "object") {
+                const srv = record.value as SrvRecordValue;
+                return `${record.recordType} ${srv.target}:${srv.port}`;
+            }
+            break;
+    }
+}
+
+export namespace DnssdName {
+    export interface Context {
+        delete(name: DnssdName): void;
+        registerForExpiration(record: Record): void;
+        unregisterForExpiration(record: Record): void;
+    }
+
+    export interface Expiration {
+        expiresAt: Timestamp;
+    }
+
+    export interface PointerRecord extends DnsRecord<string>, Expiration {
+        recordType: DnsRecordType.PTR;
+    }
+
+    export interface HostRecord extends DnsRecord<string>, Expiration {
+        recordType: DnsRecordType.A | DnsRecordType.AAAA;
+    }
+
+    export interface ServiceRecord extends DnsRecord<SrvRecordValue>, Expiration {
+        recordType: DnsRecordType.SRV;
+    }
+
+    export type Record = PointerRecord | ServiceRecord | HostRecord;
+
+    export interface Changes {
+        name: DnssdName;
+        updated?: Record[];
+        deleted?: Record[];
+    }
+}