@matter/node 0.16.0-alpha.0-20250817-1b000357c → 0.16.0-alpha.0-20250820-24939dd26

package/src/behavior/system/commissioning/CommissioningClient.ts

@@ -7,7 +7,15 @@
 import { Behavior } from "#behavior/Behavior.js";
 import { Events as BaseEvents } from "#behavior/Events.js";
 import { OperationalCredentialsClient } from "#behaviors/operational-credentials";
-import { ImplementationError, NotImplementedError, Observable, ServerAddress, Time } from "#general";
+import {
+    Duration,
+    ImplementationError,
+    NotImplementedError,
+    Observable,
+    ServerAddress,
+    Time,
+    Timestamp,
+} from "#general";
 import { DatatypeModel, FieldElement } from "#model";
 import type { ClientNode } from "#node/ClientNode.js";
 import type { Node } from "#node/Node.js";
@@ -55,7 +63,7 @@ export class CommissioningClient extends Behavior {
         }
 
         if (this.state.discoveredAt === undefined) {
-            this.state.discoveredAt = Time.nowMs();
+            this.state.discoveredAt = Time.nowMs;
         }
 
         this.reactTo((this.endpoint as Node).lifecycle.partsReady, this.#initializeNode);
@@ -120,7 +128,7 @@ export class CommissioningClient extends Behavior {
         const address = identityService.assignNodeAddress(node, fabric.fabricIndex, opts.nodeId);
 
         const commissioningOptions: LocatedNodeCommissioningOptions = {
-            addresses,
+            addresses: addresses.map(ServerAddress),
             fabric,
             nodeId: address.nodeId,
             passcode,
@@ -209,65 +217,67 @@ export class CommissioningClient extends Behavior {
     /**
      * Define logical schema.  This enables runtime validation, make fields persistent and makes subfields editable.
      */
-    static override readonly schema = new DatatypeModel({
-        name: "CommissioningState",
-        type: "struct",
-
-        children: [
-            FieldElement({
-                name: "peerAddress",
-                type: "struct",
-                quality: "N",
-                children: [
-                    FieldElement({ name: "fabricIndex", type: "fabric-id" }),
-                    FieldElement({ name: "nodeId", type: "node-id" }),
-                ],
-            }),
-            FieldElement({
-                name: "addresses",
-                type: "list",
-                quality: "N",
-                children: [
-                    FieldElement({
-                        name: "entry",
-                        type: "struct",
-                        children: [
-                            FieldElement({ name: "type", type: "string" }),
-                            FieldElement({ name: "ip", type: "string" }),
-                            FieldElement({ name: "port", type: "uint16" }),
-                            FieldElement({ name: "peripheralAddress", type: "string" }),
-                        ],
-                    }),
-                ],
-            }),
-            FieldElement({ name: "discoveredAt", type: "systime-ms", quality: "N", conformance: "M" }),
-            FieldElement({ name: "onlineAt", type: "systime-ms" }),
-            FieldElement({ name: "offlineAt", type: "systime-ms" }),
-            FieldElement({ name: "ttl", type: "uint32", quality: "N" }),
-            FieldElement({ name: "deviceIdentifier", type: "string", quality: "N" }),
-            FieldElement({ name: "discriminator", type: "uint16", quality: "N" }),
-            FieldElement({ name: "commissioningMode", type: "uint8", quality: "N" }),
-            FieldElement({ name: "vendorId", type: "vendor-id", quality: "N" }),
-            FieldElement({ name: "productId", type: "uint16", quality: "N" }),
-            FieldElement({ name: "deviceType", type: "uint16", quality: "N" }),
-            FieldElement({ name: "deviceName", type: "string", quality: "N" }),
-            FieldElement({ name: "rotatingIdentifier", type: "string", quality: "N" }),
-            FieldElement({ name: "pairingHint", type: "uint32", quality: "N" }),
-            FieldElement({ name: "pairingInstructions", type: "string", quality: "N" }),
-            FieldElement({
-                name: "sessionParameters",
-                type: "struct",
-                quality: "N",
-                children: [
-                    FieldElement({ name: "idleIntervalMs", type: "uint32", constraint: "max 3600000" }),
-                    FieldElement({ name: "activeIntervalMs", type: "uint32", constraint: "max 3600000" }),
-                    FieldElement({ name: "activeThresholdMs", type: "uint16" }),
-                ],
-            }),
-            FieldElement({ name: "tcpSupport", type: "uint8", quality: "N" }),
-            FieldElement({ name: "longIdleOperatingMode", type: "bool", quality: "N" }),
-        ],
-    });
+    static override readonly schema = new DatatypeModel(
+        {
+            name: "CommissioningState",
+            type: "struct",
+        },
+
+        FieldElement({
+            name: "peerAddress",
+            type: "struct",
+            quality: "N",
+            children: [
+                FieldElement({ name: "fabricIndex", type: "fabric-id" }),
+                FieldElement({ name: "nodeId", type: "node-id" }),
+            ],
+        }),
+
+        FieldElement({
+            name: "addresses",
+            type: "list",
+            quality: "N",
+            children: [
+                FieldElement({
+                    name: "entry",
+                    type: "struct",
+                    children: [
+                        FieldElement({ name: "type", type: "string" }),
+                        FieldElement({ name: "ip", type: "string" }),
+                        FieldElement({ name: "port", type: "uint16" }),
+                        FieldElement({ name: "peripheralAddress", type: "string" }),
+                    ],
+                }),
+            ],
+        }),
+
+        FieldElement({ name: "discoveredAt", type: "systime-ms", quality: "N", conformance: "M" }),
+        FieldElement({ name: "onlineAt", type: "systime-ms" }),
+        FieldElement({ name: "offlineAt", type: "systime-ms" }),
+        FieldElement({ name: "ttl", type: "uint32", quality: "N" }),
+        FieldElement({ name: "deviceIdentifier", type: "string", quality: "N" }),
+        FieldElement({ name: "discriminator", type: "uint16", quality: "N" }),
+        FieldElement({ name: "commissioningMode", type: "uint8", quality: "N" }),
+        FieldElement({ name: "vendorId", type: "vendor-id", quality: "N" }),
+        FieldElement({ name: "productId", type: "uint16", quality: "N" }),
+        FieldElement({ name: "deviceType", type: "uint16", quality: "N" }),
+        FieldElement({ name: "deviceName", type: "string", quality: "N" }),
+        FieldElement({ name: "rotatingIdentifier", type: "string", quality: "N" }),
+        FieldElement({ name: "pairingHint", type: "uint32", quality: "N" }),
+        FieldElement({ name: "pairingInstructions", type: "string", quality: "N" }),
+        FieldElement({
+            name: "sessionParameters",
+            type: "struct",
+            quality: "N",
+            children: [
+                FieldElement({ name: "idleInterval", type: "duration", constraint: "max 3600000" }),
+                FieldElement({ name: "activeInterval", type: "duration", constraint: "max 3600000" }),
+                FieldElement({ name: "activeThreshold", type: "duration", constraint: "max 65535" }),
+            ],
+        }),
+        FieldElement({ name: "tcpSupport", type: "uint8", quality: "N" }),
+        FieldElement({ name: "longIdleOperatingMode", type: "bool", quality: "N" }),
+    );
 }
 
 export namespace CommissioningClient {
@@ -281,27 +291,27 @@ export namespace CommissioningClient {
          * Known network addresses for the device.  If this is undefined the node has not been located on any network
          * interface.
          */
-        addresses?: ServerAddress[];
+        addresses?: ServerAddress.Definition[];
 
         /**
          * Time at which the device was discovered.
          */
-        discoveredAt?: number;
+        discoveredAt?: Timestamp;
 
         /**
          * Time at which we discovered the device's current operational addresses.
          */
-        onlineAt?: number;
+        onlineAt?: Timestamp;
 
         /**
          * Time at which we concluded the device's current operational address is unreachable.
          */
-        offlineAt?: number;
+        offlineAt?: Timestamp;
 
         /**
-         * The TTL of the discovery record if applicable.
+         * The TTL of the discovery record if applicable (in seconds).
          */
-        ttl?: number;
+        ttl?: Duration;
 
         /**
          * The canonical global ID of the device.

package/src/behavior/system/commissioning/RemoteDescriptor.ts

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { Immutable } from "#general";
+import { Immutable, Seconds, ServerAddress } from "#general";
 import { CommissionableDevice, OperationalDevice, PeerAddress, SessionParameters } from "#protocol";
 import { DeviceTypeId, VendorId } from "#types";
 import type { CommissioningClient } from "./CommissioningClient.js";
@@ -67,7 +67,7 @@ export namespace RemoteDescriptor {
         }
 
         if (ttl !== undefined) {
-            result.ttl = ttl;
+            result.ttl = Seconds(ttl);
         }
 
         if (deviceIdentifier !== undefined) {
@@ -103,18 +103,18 @@ export namespace RemoteDescriptor {
         }
 
         if (sessionParameters !== undefined) {
-            const { idleIntervalMs, activeIntervalMs, activeThresholdMs } = sessionParameters;
+            const { idleInterval, activeInterval, activeThreshold } = sessionParameters;
 
-            if (idleIntervalMs !== undefined) {
-                result.SII = idleIntervalMs;
+            if (idleInterval !== undefined) {
+                result.SII = idleInterval;
             }
 
-            if (activeIntervalMs !== undefined) {
-                result.SAI = activeIntervalMs;
+            if (activeInterval !== undefined) {
+                result.SAI = activeInterval;
             }
 
-            if (activeThresholdMs !== undefined) {
-                result.SAT = activeThresholdMs;
+            if (activeThreshold !== undefined) {
+                result.SAT = activeThreshold;
             }
         }
 
@@ -129,11 +129,11 @@ export namespace RemoteDescriptor {
         const isOperational = long.peerAddress !== undefined;
         if (isOperational) {
             if (addresses !== undefined) {
-                result.addresses = addresses?.filter(address => address.type === "udp");
+                result.addresses = addresses?.filter(address => address.type === "udp").map(ServerAddress);
             }
         } else {
             if (addresses !== undefined) {
-                result.addresses = addresses.map(address => ({ ...address }));
+                result.addresses = addresses.map(address => ({ ...address })).map(ServerAddress);
             }
 
             if (discriminator !== undefined) {
@@ -165,7 +165,7 @@ export namespace RemoteDescriptor {
         }
 
         if (addresses?.length) {
-            long.addresses = addresses;
+            long.addresses = addresses.map(ServerAddress.definitionOf);
         }
 
         if (deviceIdentifier !== undefined) {
@@ -181,13 +181,13 @@ export namespace RemoteDescriptor {
 
         let sessionParameters: Partial<SessionParameters> | undefined;
         if (SII !== undefined) {
-            (sessionParameters ??= {}).idleIntervalMs = SII;
+            (sessionParameters ??= {}).idleInterval = SII;
         }
         if (SAI !== undefined) {
-            (sessionParameters ??= {}).activeIntervalMs = SAI;
+            (sessionParameters ??= {}).activeInterval = SAI;
         }
         if (SAT !== undefined) {
-            (sessionParameters ??= {}).activeThresholdMs = SAT;
+            (sessionParameters ??= {}).activeThreshold = SAT;
         }
         long.sessionParameters = sessionParameters;
 

package/src/behavior/system/controller/discovery/ContinuousDiscovery.ts

@@ -22,7 +22,7 @@ export class ContinuousDiscovery extends Discovery<ClientNode[]> {
 
     constructor(owner: ServerNode, options?: Discovery.Options) {
         super(owner, options);
-        this.#bounded = options?.timeoutSeconds !== undefined;
+        this.#bounded = options?.timeout !== undefined;
     }
 
     /**

package/src/behavior/system/controller/discovery/Discovery.ts

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { CancelablePromise, Diagnostic, Logger, MaybePromise, withTimeout } from "#general";
+import { CancelablePromise, Diagnostic, Duration, Logger, MaybePromise, withTimeout } from "#general";
 import { ClientNodeFactory } from "#node/client/ClientNodeFactory.js";
 import type { ClientNode } from "#node/ClientNode.js";
 import type { ServerNode } from "#node/ServerNode.js";
@@ -224,8 +224,8 @@ export abstract class Discovery<T = unknown> extends CancelablePromise<T> {
 
         let promise = DiscoveryAggregateError.allSettled(promises, `${this} failed`);
 
-        if (this.#options.timeoutSeconds !== undefined) {
-            promise = withTimeout(this.#options.timeoutSeconds * 1_000, promise, this.stop.bind(this));
+        if (this.#options.timeout !== undefined) {
+            promise = withTimeout(this.#options.timeout, promise, this.stop.bind(this));
         }
 
         promise.then(this.#afterDiscovery.bind(this)).catch(this.#reject);
@@ -260,7 +260,7 @@ export abstract class Discovery<T = unknown> extends CancelablePromise<T> {
 
 export namespace Discovery {
     export type Options = CommissionableDeviceIdentifiers & {
-        timeoutSeconds?: number;
+        timeout?: Duration;
     };
 
     export type InstanceOptions = Options & {

package/src/behavior/system/network/ClientNetworkRuntime.ts

@@ -4,9 +4,9 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { InternalError, Logger, MatterError } from "#general";
+import { InternalError, Logger, MatterError, ObserverGroup } from "#general";
 import type { ClientNode } from "#node/ClientNode.js";
-import { ClientInteraction, ExchangeProvider, PeerSet } from "#protocol";
+import { ClientInteraction, ExchangeProvider, PeerAddress, PeerSet, SessionManager } from "#protocol";
 import { CommissioningClient } from "../commissioning/CommissioningClient.js";
 import { RemoteDescriptor } from "../commissioning/RemoteDescriptor.js";
 import { NetworkRuntime } from "./NetworkRuntime.js";
@@ -21,30 +21,81 @@ const logger = Logger.get("ClientNetworkRuntime");
  */
 export class ClientNetworkRuntime extends NetworkRuntime {
     #client?: ClientInteraction;
+    #observers = new ObserverGroup();
 
     constructor(owner: ClientNode) {
         super(owner);
     }
 
+    override get owner() {
+        return super.owner as ClientNode;
+    }
+
     protected async start() {
+        // Ensure we can connect to the node
         if (!this.owner.lifecycle.isCommissioned) {
             throw new UncommissionedError(`Cannot interact with ${this.owner} because it is uncommissioned`);
         }
 
-        const commissioningState = this.owner.stateOf(CommissioningClient);
+        if (this.owner.state.network.isDisabled) {
+            throw new UncommissionedError(`Cannot interact with ${this.owner} because it is disabled`);
+        }
+
         const address = this.owner.stateOf(CommissioningClient).peerAddress;
-        const peers = this.owner.env.get(PeerSet);
 
         if (address === undefined) {
             throw new InternalError(`Commissioned node ${this.owner} has no peer address`);
         }
 
+        // Install the exchange provider for the node
+        const { env, lifecycle } = this.owner;
+        const peers = env.get(PeerSet);
+        const commissioningState = this.owner.stateOf(CommissioningClient);
+
         const exchangeProvider = await peers.exchangeProviderFor(address, {
             discoveryData: RemoteDescriptor.fromLongForm(commissioningState),
         });
-        this.owner.env.set(ExchangeProvider, exchangeProvider);
+        env.set(ExchangeProvider, exchangeProvider);
+
+        // Monitor sessions to maintain online state.  We consider the node "online" if there is an active session.  If
+        // not, we consider the node offline.  This is the only real way we have of determining whether the node is
+        // healthy without actively polling
+        this.#client = env.get(ClientInteraction);
+        const { sessions } = env.get(SessionManager);
+
+        if (sessions.find(session => session.peerIs(address))) {
+            this.owner.act(({ context }) => lifecycle.online.emit(context));
+        }
 
-        this.#client = this.owner.env.get(ClientInteraction);
+        this.#observers.on(sessions.added, session => {
+            if (lifecycle.isOnline) {
+                return;
+            }
+
+            const address = PeerAddress(commissioningState.peerAddress);
+            if (!address || session.peerAddress !== address) {
+                return;
+            }
+
+            this.owner.act(({ context }) => lifecycle.online.emit(context));
+        });
+
+        this.#observers.on(sessions.deleted, session => {
+            if (!lifecycle.isOnline) {
+                return;
+            }
+
+            const address = PeerAddress(commissioningState.peerAddress);
+            if (session.peerAddress !== address) {
+                return;
+            }
+
+            if (address && sessions.find(({ peerAddress }) => peerAddress === address)) {
+                return;
+            }
+
+            this.owner.act(({ context }) => lifecycle.offline.emit(context));
+        });
     }
 
     protected async stop() {
@@ -55,6 +106,8 @@ export class ClientNetworkRuntime extends NetworkRuntime {
         } catch (e) {
             logger.error(`Error closing connection to ${this.owner}`, e);
         }
+
+        this.#observers.close();
     }
 
     blockNewActivity() {

package/src/behavior/system/network/NetworkBehavior.ts

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { STANDARD_MATTER_PORT } from "#general";
+import { MaybePromise, STANDARD_MATTER_PORT } from "#general";
 import { Behavior } from "../../Behavior.js";
 import type { NetworkRuntime } from "./NetworkRuntime.js";
 
@@ -24,6 +24,11 @@ export class NetworkBehavior extends Behavior {
     override [Symbol.asyncDispose]() {
         return this.internal.runtime?.close();
     }
+
+    /**
+     * Invoked by node when networking is ready.
+     */
+    startup(): MaybePromise {}
 }
 
 export namespace NetworkBehavior {

package/src/behavior/system/network/NetworkClient.ts

@@ -6,7 +6,7 @@
 
 import { DatatypeModel, FieldElement } from "#model";
 import { Node } from "#node/Node.js";
-import { DEFAULT_MIN_INTERVAL_FLOOR_SECONDS, Subscribe } from "#protocol";
+import { DEFAULT_MIN_INTERVAL_FLOOR, Subscribe } from "#protocol";
 import { ClientNetworkRuntime } from "./ClientNetworkRuntime.js";
 import { NetworkBehavior } from "./NetworkBehavior.js";
 
@@ -14,22 +14,18 @@ export class NetworkClient extends NetworkBehavior {
     declare internal: NetworkClient.Internal;
     declare state: NetworkClient.State;
 
-    override initialize() {
-        this.reactTo(this.#node.lifecycle.online, this.startup);
-    }
-
-    protected async startup() {
-        const { startupSubscription } = this.state;
+    override async startup() {
+        const { startupSubscription, isDisabled } = this.state;
 
-        if (startupSubscription === null) {
+        if (startupSubscription === null || isDisabled) {
             return;
         }
 
         // TODO - configure subscription based on physical device properties
         const subscribe = Subscribe({
             fabricFilter: true,
-            minIntervalFloorSeconds: DEFAULT_MIN_INTERVAL_FLOOR_SECONDS,
-            maxIntervalCeilingSeconds: 0,
+            minIntervalFloor: DEFAULT_MIN_INTERVAL_FLOOR,
+            maxIntervalCeiling: 0,
             attributes: [{}],
             ...startupSubscription,
         });
@@ -59,6 +55,12 @@ export class NetworkClient extends NetworkBehavior {
                 default: { type: "properties", properties: {} },
                 quality: "XN",
             }),
+
+            FieldElement({
+                name: "isDisabled",
+                type: "bool",
+                quality: "N",
+            }),
         ],
     });
 }
@@ -72,11 +74,16 @@ export namespace NetworkClient {
         /**
          * A subscription installed when the node is first commissioned and when the service is restarted.
          *
-         * The default subscription is a wildcard for all attributes and of the node.  You can set to undefined or
-         * filter the fields and values but only values selected by this subscription will update automatically.
+         * The default subscription is a wildcard for all attributes of the node.  You can set to undefined or filter
+         * the fields and values but only values selected by this subscription will update automatically.
          *
          * Set to null to disable automatic subscription.
          */
         startupSubscription?: Subscribe | null;
+
+        /**
+         * If true, the matter.js will not perform network communication with the node.
+         */
+        isDisabled = false;
     }
 }

package/src/behavior/system/network/NetworkRuntime.ts

@@ -34,7 +34,6 @@ export abstract class NetworkRuntime {
 
     async [Construction.construct]() {
         await this.start();
-        await this.#owner.act(agent => this.owner.lifecycle.online.emit(agent.context));
     }
 
     async [Construction.destruct]() {

package/src/behavior/system/network/ServerNetworkRuntime.ts

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { SubscriptionBehavior } from "#behavior/system/subscription/SubscriptionBehavior.js";
+import { SubscriptionsBehavior } from "#behavior/system/subscriptions/SubscriptionsServer.js";
 import {
     Construction,
     Crypto,
@@ -293,6 +293,8 @@ export class ServerNetworkRuntime extends NetworkRuntime {
         if (this.owner.stateOf(CommissioningServer).commissioned) {
             this.enableMdnsAdvertising();
         }
+
+        await this.owner.act(agent => this.owner.lifecycle.online.emit(agent.context));
     }
 
     override async [Construction.construct]() {
@@ -355,7 +357,7 @@ export class ServerNetworkRuntime extends NetworkRuntime {
         this.#formerSubscriptionsHandled = true;
 
         await this.owner.act(agent =>
-            agent.get(SubscriptionBehavior).reestablishFormerSubscriptions(env.get(InteractionServer)),
+            agent.get(SubscriptionsBehavior).reestablishFormerSubscriptions(env.get(InteractionServer)),
         );
     }
 

package/src/behavior/system/sessions/SessionsBehavior.ts

@@ -72,7 +72,7 @@ export class SessionsBehavior extends Behavior {
             return;
         }
 
-        // When subscription was added then inform SubscriptionBehavior
+        // When subscription was added then inform SubscriptionsBehavior
         if (session.subscriptions.has(subscription)) {
             this.events.subscriptionAdded.emit(subscription);
         }

package/src/behavior/system/{subscription/SubscriptionBehavior.ts → subscriptions/SubscriptionsServer.ts}

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { deepCopy, isIpNetworkChannel, Logger, MatterError, MaybePromise, ServerAddressIp } from "#general";
+import { deepCopy, isIpNetworkChannel, Logger, MatterError, MaybePromise, Seconds, ServerAddressIp } from "#general";
 import { DatatypeModel, FieldElement } from "#model";
 import { InteractionServer, PeerSubscription } from "#node/server/InteractionServer.js";
 import { ServerSubscription } from "#node/server/ServerSubscription.js";
@@ -21,10 +21,10 @@ import {
 import { StatusCode, StatusResponseError } from "#types";
 import { Behavior } from "../../Behavior.js";
 import { SessionsBehavior } from "../sessions/SessionsBehavior.js";
-const logger = Logger.get("SubscriptionBehavior");
+const logger = Logger.get("SubscriptionsBehavior");
 
 /** Timeout in seconds to wait for responses or discovery of the peer node when trying to re-establish a subscription. */
-const REESTABLISH_SUBSCRIPTIONS_TIMEOUT_S = 2;
+const REESTABLISH_SUBSCRIPTIONS_TIMEOUT = Seconds(2);
 
 /**
  * Subscriptions Persistence handling.
@@ -33,11 +33,11 @@ const REESTABLISH_SUBSCRIPTIONS_TIMEOUT_S = 2;
  * speed up the controller reconnection process. This can mean a bit more memory usage on start of the device. To
  * disable this feature set `persistenceEnabled` as state of the `subscription` behavior to `false`.
  */
-export class SubscriptionBehavior extends Behavior {
-    static override readonly id = "subscription";
+export class SubscriptionsBehavior extends Behavior {
+    static override readonly id = "subscriptions";
 
-    declare state: SubscriptionBehavior.State;
-    declare internal: SubscriptionBehavior.Internal;
+    declare state: SubscriptionsBehavior.State;
+    declare internal: SubscriptionsBehavior.Internal;
 
     override initialize() {
         if (this.state.subscriptions !== undefined && this.state.persistenceEnabled !== false) {
@@ -115,10 +115,10 @@ export class SubscriptionBehavior extends Behavior {
                     ),
                 ),
                 FieldElement({ name: "isFabricFiltered", type: "bool" }),
-                FieldElement({ name: "maxIntervalCeilingSeconds", type: "uint16" }),
-                FieldElement({ name: "minIntervalFloorSeconds", type: "uint16" }),
-                FieldElement({ name: "maxInterval", type: "uint16" }),
-                FieldElement({ name: "sendInterval", type: "uint16" }),
+                FieldElement({ name: "maxIntervalCeiling", type: "duration" }),
+                FieldElement({ name: "minIntervalFloor", type: "duration" }),
+                FieldElement({ name: "maxInterval", type: "duration" }),
+                FieldElement({ name: "sendInterval", type: "duration" }),
                 FieldElement(
                     {
                         name: "operationalAddress",
@@ -142,8 +142,8 @@ export class SubscriptionBehavior extends Behavior {
             maxInterval,
             sendInterval,
             id,
-            maxIntervalCeilingSeconds,
-            minIntervalFloorSeconds,
+            maxIntervalCeiling,
+            minIntervalFloor,
         } = subscription;
         const { peerAddress } = session;
         const { fabricIndex, nodeId } = peerAddress;
@@ -160,8 +160,8 @@ export class SubscriptionBehavior extends Behavior {
         const peerSubscription: PeerSubscription = {
             subscriptionId: id,
             peerAddress: { fabricIndex, nodeId },
-            maxIntervalCeilingSeconds,
-            minIntervalFloorSeconds,
+            maxIntervalCeiling,
+            minIntervalFloor,
             attributeRequests,
             eventRequests,
             isFabricFiltered,
@@ -234,7 +234,7 @@ export class SubscriptionBehavior extends Behavior {
                     await peers.ensureConnection(peerAddress, {
                         discoveryOptions: {
                             discoveryType: NodeDiscoveryType.TimedDiscovery,
-                            timeoutSeconds: REESTABLISH_SUBSCRIPTIONS_TIMEOUT_S,
+                            timeout: REESTABLISH_SUBSCRIPTIONS_TIMEOUT,
                         },
                         allowUnknownPeer: true,
                         operationalAddress,
@@ -282,7 +282,7 @@ export class SubscriptionBehavior extends Behavior {
     }
 }
 
-export namespace SubscriptionBehavior {
+export namespace SubscriptionsBehavior {
     export class State {
         /** Set to false if persistence of subscriptions should be disabled */
         persistenceEnabled = true;