@willieee802/zigbee-herdsman 0.49.3 → 0.50.0

package/src/adapter/deconz/adapter/deconzAdapter.ts

@@ -12,7 +12,7 @@ import type {BroadcastAddress} from "../../../zspec/enums";
 import * as Zcl from "../../../zspec/zcl";
 import * as Zdo from "../../../zspec/zdo";
 import type * as ZdoTypes from "../../../zspec/zdo/definition/tstypes";
-import Adapter from "../../adapter";
+import Adapter, {type ClusterWaitressMatcher, type ZclWaitressPayload} from "../../adapter";
 import type * as Events from "../../events";
 import type {AdapterOptions, CoordinatorVersion, NetworkOptions, NetworkParameters, SerialPortOptions, StartResult} from "../../tstype";
 import {readBackup} from "../../utils";
@@ -30,23 +30,13 @@ import processFrame, {frameParserEvents} from "../driver/frameParser";
 
 const NS = "zh:deconz";
 
-interface WaitressMatcher {
-    address?: number | string;
-    endpoint: number;
-    transactionSequenceNumber?: number;
-    frameType: Zcl.FrameType;
-    clusterID: number;
-    commandIdentifier: number;
-    direction: number;
-}
-
 export class DeconzAdapter extends Adapter {
     private driver: Driver;
     private openRequestsQueue: WaitForDataRequest[];
     private frameParserEvent = frameParserEvents;
     // biome-ignore lint/correctness/noUnusedPrivateClassMembers: ignore
     private fwVersion?: CoordinatorVersion;
-    private waitress: Waitress<Events.ZclPayload, WaitressMatcher>;
+    private waitress: Waitress<ZclWaitressPayload, ClusterWaitressMatcher>;
     private joinPermitted = false;
 
     public constructor(networkOptions: NetworkOptions, serialPortOptions: SerialPortOptions, backupPath: string, adapterOptions: AdapterOptions) {
@@ -54,7 +44,7 @@ export class DeconzAdapter extends Adapter {
         this.hasZdoMessageOverhead = true;
         this.manufacturerID = Zcl.ManufacturerCode.DRESDEN_ELEKTRONIK_INGENIEURTECHNIK_GMBH;
 
-        this.waitress = new Waitress<Events.ZclPayload, WaitressMatcher>(this.waitressValidator, this.waitressTimeoutFormatter);
+        this.waitress = new Waitress(Adapter.zclWaitressValidator, Adapter.clusterWaitressTimeoutFormatter);
 
         const firmwareLog = [];
         if (backupPath) {
@@ -205,24 +195,17 @@ export class DeconzAdapter extends Adapter {
     }
 
     public waitFor(
-        networkAddress: number | undefined,
+        networkAddress: number,
         endpoint: number,
-        frameType: Zcl.FrameType,
-        direction: Zcl.Direction,
+        _frameType: Zcl.FrameType,
+        _direction: Zcl.Direction,
         transactionSequenceNumber: number | undefined,
-        clusterID: number,
-        commandIdentifier: number,
+        clusterId: number,
+        commandId: number,
+        defaultRspCommandId: number | undefined,
         timeout: number,
     ): {promise: Promise<Events.ZclPayload>; cancel: () => void} {
-        const payload = {
-            address: networkAddress,
-            endpoint,
-            clusterID,
-            commandIdentifier,
-            frameType,
-            direction,
-            transactionSequenceNumber,
-        };
+        const payload = {address: networkAddress, endpoint, clusterId, commandId, defaultRspCommandId, transactionSequenceNumber};
 
         logger.debug(() => `waitFor() called ${JSON.stringify(payload)}`, NS);
 
@@ -370,7 +353,12 @@ export class DeconzAdapter extends Adapter {
         // TODO(mpi): Enable APS ACKs for tricky devices, maintain a list of those, or keep at least a few slots free for non APS ACK requests.
         //const txOptions = 0x4; // 0x00 normal, 0x04 APS ACK
         // TODO(mpi): Disable APS ACKs for now until we find a better solution to not block queues.
-        const txOptions = 0;
+        let txOptions = 0x00;
+
+        // Zigbee Direct cluster, enable APS layer encryption
+        if (zclFrame.cluster.ID === Zcl.Clusters.zigbeeDirectConfiguration.ID) {
+            txOptions |= 0x01;
+        }
 
         const request: ApsDataRequest = {
             requestId: transactionID,
@@ -713,7 +701,10 @@ export class DeconzAdapter extends Adapter {
             destinationEndpoint: ZSpec.GP_ENDPOINT,
         };
 
-        this.waitress.resolve(payload);
+        if (payload.header !== undefined) {
+            this.waitress.resolve(payload as ZclWaitressPayload);
+        }
+
         this.emit("zclPayload", payload);
     }
 
@@ -856,7 +847,10 @@ export class DeconzAdapter extends Adapter {
                 destinationEndpoint: resp.destEndpoint,
             };
 
-            this.waitress.resolve(payload);
+            if (payload.header !== undefined) {
+                this.waitress.resolve(payload as ZclWaitressPayload);
+            }
+
             this.emit("zclPayload", payload);
         }
     }
@@ -864,25 +858,4 @@ export class DeconzAdapter extends Adapter {
     private nextTransactionID(): number {
         return this.driver.nextTransactionID();
     }
-
-    private waitressTimeoutFormatter(matcher: WaitressMatcher, timeout: number): string {
-        return (
-            `Timeout - ${matcher.address} - ${matcher.endpoint}` +
-            ` - ${matcher.transactionSequenceNumber} - ${matcher.clusterID}` +
-            ` - ${matcher.commandIdentifier} after ${timeout}ms`
-        );
-    }
-
-    private waitressValidator(payload: Events.ZclPayload, matcher: WaitressMatcher): boolean {
-        return Boolean(
-            payload.header &&
-                (!matcher.address || payload.address === matcher.address) &&
-                payload.endpoint === matcher.endpoint &&
-                (matcher.transactionSequenceNumber === undefined || payload.header.transactionSequenceNumber === matcher.transactionSequenceNumber) &&
-                payload.clusterID === matcher.clusterID &&
-                matcher.frameType === payload.header.frameControl.frameType &&
-                matcher.commandIdentifier === payload.header.commandIdentifier &&
-                matcher.direction === payload.header.frameControl.direction,
-        );
-    }
 }

package/src/adapter/deconz/driver/constants.ts

@@ -241,6 +241,6 @@ interface ApsDataRequest {
 
 type Command = Buffer | number | bigint;
 
-export type {ApsRequest, Request, WaitForDataRequest, ApsDataRequest, ReceivedDataResponse, DataStateResponse, Command, GpDataInd};
+export type {ApsDataRequest, ApsRequest, Command, DataStateResponse, GpDataInd, ReceivedDataResponse, Request, WaitForDataRequest};
 
 export default {PARAM};

package/src/adapter/ember/adapter/emberAdapter.ts

@@ -957,16 +957,22 @@ export class EmberAdapter extends Adapter {
                 logger.info("[INIT TC] Forming from backup.", NS);
                 // `backup` valid in this `action` path (not detected by TS)
                 /* v8 ignore start */
+                const keyList: LinkKeyBackupData[] = [];
+
                 // biome-ignore lint/style/noNonNullAssertion: ignored using `--suppress`
-                const keyList: LinkKeyBackupData[] = backup!.devices.map((device) => ({
-                    deviceEui64: ZSpec.Utils.eui64BEBufferToHex(device.ieeeAddress),
-                    // biome-ignore lint/style/noNonNullAssertion: ignored using `--suppress`
-                    key: {contents: device.linkKey!.key},
-                    // biome-ignore lint/style/noNonNullAssertion: ignored using `--suppress`
-                    outgoingFrameCounter: device.linkKey!.txCounter,
-                    // biome-ignore lint/style/noNonNullAssertion: ignored using `--suppress`
-                    incomingFrameCounter: device.linkKey!.rxCounter,
-                }));
+                for (const device of backup!.devices) {
+                    // link_key is optional in the open coordinator backup format, skip devices without one
+                    if (device.linkKey == null) {
+                        continue;
+                    }
+
+                    keyList.push({
+                        deviceEui64: ZSpec.Utils.eui64BEBufferToHex(device.ieeeAddress),
+                        key: {contents: device.linkKey.key},
+                        outgoingFrameCounter: device.linkKey.txCounter,
+                        incomingFrameCounter: device.linkKey.rxCounter,
+                    });
+                }
                 /* v8 ignore stop */
 
                 // before forming
@@ -1705,13 +1711,14 @@ export class EmberAdapter extends Adapter {
 
     /** WARNING: Adapter impl. Starts timer immediately upon returning */
     public waitFor(
-        networkAddress: number | undefined,
+        networkAddress: number,
         endpoint: number,
         _frameType: Zcl.FrameType,
         _direction: Zcl.Direction,
         transactionSequenceNumber: number | undefined,
         clusterID: number,
         commandIdentifier: number,
+        defaultRspCommandId: number | undefined,
         timeout: number,
     ): {promise: Promise<ZclPayload>; cancel: () => void} {
         const sourceEndpointInfo = FIXED_ENDPOINTS[0];
@@ -1729,6 +1736,7 @@ export class EmberAdapter extends Adapter {
                 },
                 zclSequence: transactionSequenceNumber,
                 commandIdentifier,
+                defaultRspCommandId,
             },
             timeout,
         );
@@ -1958,6 +1966,11 @@ export class EmberAdapter extends Adapter {
             apsFrame.options &= ~EmberApsOption.RETRY;
         }
 
+        // Zigbee Direct cluster, enable APS layer encryption
+        if (zclFrame.cluster.ID === Zcl.Clusters.zigbeeDirectConfiguration.ID) {
+            apsFrame.options |= EmberApsOption.ENCRYPTION;
+        }
+
         const data = zclFrame.toBuffer();
 
         return await this.queue.execute<ZclPayload | undefined>(async () => {

package/src/adapter/ember/adapter/oneWaitress.ts

@@ -1,9 +1,9 @@
 /* v8 ignore start */
 
 import equals from "fast-deep-equal/es6";
-
 import {TOUCHLINK_PROFILE_ID} from "../../../zspec/consts";
 import type {Eui64, NodeId} from "../../../zspec/tstypes";
+import {FrameType} from "../../../zspec/zcl";
 import type {ZclPayload} from "../../events";
 import type {EmberApsFrame} from "../types";
 
@@ -29,6 +29,8 @@ type OneWaitressMatcher = {
     zclSequence?: number;
     /** Expected command ID for ZCL commands */
     commandIdentifier?: number;
+    /** Expected default response command ID for ZCL commands */
+    defaultRspCommandId?: number;
 };
 
 type OneWaitressEventMatcher = {
@@ -154,13 +156,21 @@ export class EmberOneWaitress {
                 continue;
             }
 
+            const {matcher} = waiter;
+            const {address, endpoint, clusterID, header} = payload;
+
             // no target in touchlink, also no APS sequence, but use the ZCL one instead
             if (
-                (waiter.matcher.apsFrame.profileId === TOUCHLINK_PROFILE_ID ||
-                    (payload.address === waiter.matcher.target && payload.endpoint === waiter.matcher.apsFrame.destinationEndpoint)) &&
-                (waiter.matcher.zclSequence === undefined || payload.header.transactionSequenceNumber === waiter.matcher.zclSequence) &&
-                (waiter.matcher.commandIdentifier === undefined || payload.header.commandIdentifier === waiter.matcher.commandIdentifier) &&
-                payload.clusterID === waiter.matcher.apsFrame.clusterId
+                (matcher.apsFrame.profileId === TOUCHLINK_PROFILE_ID ||
+                    (address === matcher.target && endpoint === matcher.apsFrame.destinationEndpoint)) &&
+                clusterID === matcher.apsFrame.clusterId &&
+                (matcher.zclSequence === undefined || header.transactionSequenceNumber === matcher.zclSequence) &&
+                (matcher.commandIdentifier === undefined ||
+                    header.commandIdentifier === matcher.commandIdentifier ||
+                    // defaultRsp
+                    (header.frameControl.frameType === FrameType.GLOBAL &&
+                        header.commandIdentifier === 0x0b &&
+                        (matcher.defaultRspCommandId === undefined || payload.data[payload.data.byteLength - 2] === matcher.defaultRspCommandId)))
             ) {
                 clearTimeout(waiter.timer);
 

package/src/adapter/ezsp/adapter/ezspAdapter.ts

@@ -1,7 +1,6 @@
 /* v8 ignore start */
 
 import assert from "node:assert";
-
 import type * as Models from "../../../models";
 import {Queue, Waitress, wait} from "../../../utils";
 import {logger} from "../../../utils/logger";
@@ -9,7 +8,7 @@ import * as ZSpec from "../../../zspec";
 import * as Zcl from "../../../zspec/zcl";
 import * as Zdo from "../../../zspec/zdo";
 import type * as ZdoTypes from "../../../zspec/zdo/definition/tstypes";
-import Adapter from "../../adapter";
+import Adapter, {type ClusterWaitressMatcher, type ZclWaitressPayload} from "../../adapter";
 import type {ZclPayload} from "../../events";
 import type {AdapterOptions, CoordinatorVersion, NetworkOptions, NetworkParameters, SerialPortOptions, StartResult} from "../../tstype";
 import {Driver, type EmberIncomingMessage} from "../driver";
@@ -17,17 +16,9 @@ import {EmberEUI64, EmberStatus} from "../driver/types";
 
 const NS = "zh:ezsp";
 
-interface WaitressMatcher {
-    address?: number | string;
-    endpoint: number;
-    transactionSequenceNumber?: number;
-    clusterID: number;
-    commandIdentifier: number;
-}
-
 export class EZSPAdapter extends Adapter {
     private driver: Driver;
-    private waitress: Waitress<ZclPayload, WaitressMatcher>;
+    private waitress: Waitress<ZclWaitressPayload, ClusterWaitressMatcher>;
     private interpanLock: boolean;
     private queue: Queue;
     private closing: boolean;
@@ -37,7 +28,7 @@ export class EZSPAdapter extends Adapter {
         this.hasZdoMessageOverhead = true;
         this.manufacturerID = Zcl.ManufacturerCode.SILICON_LABORATORIES;
 
-        this.waitress = new Waitress<ZclPayload, WaitressMatcher>(this.waitressValidator, this.waitressTimeoutFormatter);
+        this.waitress = new Waitress(Adapter.zclWaitressValidator, Adapter.clusterWaitressTimeoutFormatter);
         this.interpanLock = false;
         this.closing = false;
 
@@ -78,7 +69,10 @@ export class EZSPAdapter extends Adapter {
                 destinationEndpoint: frame.apsFrame.destinationEndpoint,
             };
 
-            this.waitress.resolve(payload);
+            if (payload.header !== undefined) {
+                this.waitress.resolve(payload as ZclWaitressPayload);
+            }
+
             this.emit("zclPayload", payload);
         } else if (frame.apsFrame.profileId === ZSpec.TOUCHLINK_PROFILE_ID && frame.senderEui64) {
             // ZLL Frame
@@ -94,7 +88,10 @@ export class EZSPAdapter extends Adapter {
                 destinationEndpoint: 1,
             };
 
-            this.waitress.resolve(payload);
+            if (payload.header !== undefined) {
+                this.waitress.resolve(payload as ZclWaitressPayload);
+            }
+
             this.emit("zclPayload", payload);
         } else if (frame.apsFrame.profileId === ZSpec.GP_PROFILE_ID) {
             // GP Frame
@@ -114,7 +111,10 @@ export class EZSPAdapter extends Adapter {
                     destinationEndpoint: frame.apsFrame.sourceEndpoint,
                 };
 
-                this.waitress.resolve(payload);
+                if (payload.header !== undefined) {
+                    this.waitress.resolve(payload as ZclWaitressPayload);
+                }
+
                 this.emit("zclPayload", payload);
             } else {
                 logger.debug("Ignoring GP frame because clusterId is not greenPower", NS);
@@ -373,6 +373,7 @@ export class EZSPAdapter extends Adapter {
                 zclFrame.header.transactionSequenceNumber,
                 zclFrame.cluster.ID,
                 command.response,
+                undefined,
                 timeout,
             );
         } else if (!zclFrame.header.frameControl.disableDefaultResponse) {
@@ -382,6 +383,7 @@ export class EZSPAdapter extends Adapter {
                 zclFrame.header.transactionSequenceNumber,
                 zclFrame.cluster.ID,
                 Zcl.Foundation.defaultRsp.ID,
+                undefined,
                 timeout,
             );
         }
@@ -540,7 +542,7 @@ export class EZSPAdapter extends Adapter {
             let response: ReturnType<typeof this.waitForInternal> | undefined;
 
             if (!disableResponse && command.response !== undefined) {
-                this.waitForInternal(undefined, 0xfe, undefined, zclFrame.cluster.ID, command.response, timeout);
+                this.waitForInternal(undefined, 0xfe, undefined, zclFrame.cluster.ID, command.response, undefined, timeout);
             }
 
             try {
@@ -578,18 +580,13 @@ export class EZSPAdapter extends Adapter {
         networkAddress: number | undefined,
         endpoint: number,
         transactionSequenceNumber: number | undefined,
-        clusterID: number,
-        commandIdentifier: number,
+        clusterId: number,
+        commandId: number,
+        defaultRspCommandId: number | undefined,
         timeout: number,
     ): {start: () => {promise: Promise<ZclPayload>}; cancel: () => void} {
         const waiter = this.waitress.waitFor(
-            {
-                address: networkAddress,
-                endpoint,
-                clusterID,
-                commandIdentifier,
-                transactionSequenceNumber,
-            },
+            {address: networkAddress, endpoint, clusterId, commandId, defaultRspCommandId, transactionSequenceNumber},
             timeout,
         );
         const cancel = (): void => this.waitress.remove(waiter.ID);
@@ -597,36 +594,18 @@ export class EZSPAdapter extends Adapter {
     }
 
     public waitFor(
-        networkAddress: number | undefined,
+        networkAddress: number,
         endpoint: number,
         _frameType: Zcl.FrameType,
         _direction: Zcl.Direction,
         transactionSequenceNumber: number | undefined,
-        clusterID: number,
-        commandIdentifier: number,
+        clusterId: number,
+        commandId: number,
+        defaultRspCommandId: number | undefined,
         timeout: number,
     ): {promise: Promise<ZclPayload>; cancel: () => void} {
-        const waiter = this.waitForInternal(networkAddress, endpoint, transactionSequenceNumber, clusterID, commandIdentifier, timeout);
+        const waiter = this.waitForInternal(networkAddress, endpoint, transactionSequenceNumber, clusterId, commandId, defaultRspCommandId, timeout);
 
         return {cancel: waiter.cancel, promise: waiter.start().promise};
     }
-
-    private waitressTimeoutFormatter(matcher: WaitressMatcher, timeout: number): string {
-        return (
-            `Timeout - ${matcher.address} - ${matcher.endpoint}` +
-            ` - ${matcher.transactionSequenceNumber} - ${matcher.clusterID}` +
-            ` - ${matcher.commandIdentifier} after ${timeout}ms`
-        );
-    }
-
-    private waitressValidator(payload: ZclPayload, matcher: WaitressMatcher): boolean {
-        return Boolean(
-            payload.header &&
-                (!matcher.address || payload.address === matcher.address) &&
-                payload.endpoint === matcher.endpoint &&
-                (matcher.transactionSequenceNumber === undefined || payload.header.transactionSequenceNumber === matcher.transactionSequenceNumber) &&
-                payload.clusterID === matcher.clusterID &&
-                matcher.commandIdentifier === payload.header.commandIdentifier,
-        );
-    }
 }

package/src/adapter/ezsp/driver/index.ts

@@ -1,4 +1,4 @@
 import {Driver, EmberIncomingMessage} from "./driver";
 import {Ezsp} from "./ezsp";
 
-export {Ezsp, Driver, EmberIncomingMessage};
+export {Driver, EmberIncomingMessage, Ezsp};

package/src/adapter/ezsp/driver/types/index.ts

@@ -121,119 +121,119 @@ export function serialize(data: any[], schema: {serialize: (schema: any, item: a
 }
 
 export {
-    /* Basic Types */
-    int8s,
-    uint_t,
-    uint8_t,
-    uint16_t,
-    uint24_t,
-    uint32_t,
-    uint64_t,
-    LVBytes,
-    list,
-    LVList,
-    fixed_list,
-    WordList,
-    Bytes,
-    /* Named Types */
-    NcpResetCode,
-    EmberRf4ceTxOption,
-    EmberRf4ceNodeCapabilities,
-    EmberRf4ceApplicationCapabilities,
-    EmberNodeId,
-    EmberPanId,
-    EmberMulticastId,
-    EmberEUI64,
-    EmberLibraryStatus,
-    SecureEzspSecurityType,
-    SecureEzspSecurityLevel,
-    EmberGpSecurityLevel,
-    EmberGpKeyType,
-    SecureEzspRandomNumber,
-    SecureEzspSessionId,
     Bool,
-    EzspConfigId,
-    EzspValueId,
-    EzspExtendedValueId,
-    EzspEndpointFlags,
+    Bytes,
+    EmberAesMmoHashContext,
+    EmberApsFrame,
+    EmberApsOption,
+    EmberBindingTableEntry,
+    EmberBindingType,
+    EmberCertificate283k1Data,
+    EmberCertificateData,
+    EmberConcentratorType,
     EmberConfigTxPowerMode,
-    EzspPolicyId,
-    EzspDecisionId,
-    EzspMfgTokenId,
-    EzspStatus,
-    EmberStatus,
-    SLStatus,
-    EmberStackError,
+    EmberCounterType,
+    EmberCurrentSecurityBitmask,
+    EmberCurrentSecurityState,
+    EmberDerivedKeyType,
+    EmberDeviceUpdate,
+    EmberEUI64,
     EmberEventUnits,
-    EmberNodeType,
-    EmberNetworkStatus,
+    EmberGpAddress,
+    EmberGpKeyType,
+    EmberGpSecurityLevel,
+    EmberGpSinkListEntry,
     EmberIncomingMessageType,
-    EmberOutgoingMessageType,
-    EmberMacPassthroughType,
-    EmberBindingType,
-    EmberApsOption,
-    EzspNetworkScanType,
-    EmberJoinDecision,
     EmberInitialSecurityBitmask,
-    EmberCurrentSecurityBitmask,
-    EmberKeyType,
-    EmberKeyStructBitmask,
-    EmberDeviceUpdate,
-    EmberKeyStatus,
-    EmberCounterType,
+    EmberInitialSecurityState,
+    EmberJoinDecision,
     EmberJoinMethod,
-    EmberZdoConfigurationFlags,
-    EmberConcentratorType,
-    EmberZllState,
-    EmberZllKeyIndex,
-    EzspZllNetworkOperation,
-    EzspSourceRouteOverheadInformation,
-    EmberNetworkInitBitmask,
-    EmberZDOCmd,
-    EmberDerivedKeyType,
-    /* Structs */
-    EzspStruct,
-    EmberNetworkParameters,
-    EmberZigbeeNetwork,
-    EmberApsFrame,
-    EmberBindingTableEntry,
-    EmberMulticastTableEntry,
     EmberKeyData,
-    EmberCertificateData,
-    EmberPublicKeyData,
-    EmberPrivateKeyData,
-    EmberSmacData,
-    EmberSignatureData,
-    EmberCertificate283k1Data,
-    EmberPublicKey283k1Data,
-    EmberPrivateKey283k1Data,
-    EmberSignature283k1Data,
+    EmberKeyStatus,
+    EmberKeyStruct,
+    EmberKeyStructBitmask,
+    EmberKeyType,
+    EmberLibraryStatus,
+    EmberMacPassthroughType,
     EmberMessageDigest,
-    EmberAesMmoHashContext,
+    EmberMultiAddress,
+    EmberMulticastId,
+    EmberMulticastTableEntry,
+    EmberNeighbors,
     EmberNeighborTableEntry,
-    EmberRouteTableEntry,
-    EmberInitialSecurityState,
-    EmberCurrentSecurityState,
-    EmberKeyStruct,
+    EmberNetworkInitBitmask,
     EmberNetworkInitStruct,
-    EmberZllSecurityAlgorithmData,
-    EmberZllNetwork,
-    EmberZllInitialSecurityState,
-    EmberZllDeviceInfoRecord,
-    EmberZllAddressAssignment,
-    EmberTokTypeStackZllData,
-    EmberTokTypeStackZllSecurity,
-    EmberRf4ceVendorInfo,
+    EmberNetworkParameters,
+    EmberNetworkStatus,
+    EmberNodeDescriptor,
+    EmberNodeId,
+    EmberNodeType,
+    EmberOutgoingMessageType,
+    EmberPanId,
+    EmberPrivateKey283k1Data,
+    EmberPrivateKeyData,
+    EmberPublicKey283k1Data,
+    EmberPublicKeyData,
+    EmberRf4ceApplicationCapabilities,
     EmberRf4ceApplicationInfo,
+    EmberRf4ceNodeCapabilities,
     EmberRf4cePairingTableEntry,
-    EmberGpAddress,
-    EmberGpSinkListEntry,
-    EmberNodeDescriptor,
-    EmberSimpleDescriptor,
-    EmberMultiAddress,
-    EmberNeighbors,
+    EmberRf4ceTxOption,
+    EmberRf4ceVendorInfo,
+    EmberRouteTableEntry,
     EmberRoutingTable,
     EmberRoutingTableEntry,
     EmberSecurityManagerContext,
     EmberSecurityManagerNetworkKeyInfo,
+    EmberSignature283k1Data,
+    EmberSignatureData,
+    EmberSimpleDescriptor,
+    EmberSmacData,
+    EmberStackError,
+    EmberStatus,
+    EmberTokTypeStackZllData,
+    EmberTokTypeStackZllSecurity,
+    EmberZDOCmd,
+    EmberZdoConfigurationFlags,
+    EmberZigbeeNetwork,
+    EmberZllAddressAssignment,
+    EmberZllDeviceInfoRecord,
+    EmberZllInitialSecurityState,
+    EmberZllKeyIndex,
+    EmberZllNetwork,
+    EmberZllSecurityAlgorithmData,
+    EmberZllState,
+    EzspConfigId,
+    EzspDecisionId,
+    EzspEndpointFlags,
+    EzspExtendedValueId,
+    EzspMfgTokenId,
+    EzspNetworkScanType,
+    EzspPolicyId,
+    EzspSourceRouteOverheadInformation,
+    EzspStatus,
+    /* Structs */
+    EzspStruct,
+    EzspValueId,
+    EzspZllNetworkOperation,
+    fixed_list,
+    /* Basic Types */
+    int8s,
+    LVBytes,
+    LVList,
+    list,
+    /* Named Types */
+    NcpResetCode,
+    SecureEzspRandomNumber,
+    SecureEzspSecurityLevel,
+    SecureEzspSecurityType,
+    SecureEzspSessionId,
+    SLStatus,
+    uint_t,
+    uint8_t,
+    uint16_t,
+    uint24_t,
+    uint32_t,
+    uint64_t,
+    WordList,
 };

package/src/adapter/serialPort.ts

@@ -1,5 +1,6 @@
 /* v8 ignore start */
 
+import {platform} from "node:os";
 import {type AutoDetectTypes, autoDetect, type OpenOptionsFromBinding, type SetOptions} from "@serialport/bindings-cpp";
 // This file was copied from https://github.com/serialport/node-serialport/blob/master/packages/serialport/lib/serialport.ts.
 import {type ErrorCallback, type OpenOptions, SerialPortStream, type StreamOptions} from "@serialport/stream";
@@ -17,6 +18,14 @@ export class SerialPort<T extends AutoDetectTypes = AutoDetectTypes> extends Ser
             binding: DetectedBinding as T,
             ...options,
         };
+
+        if (platform() === "win32") {
+            // this controls `DTR` on "open", whereas on Unix, it's on "close"
+            // https://github.com/serialport/bindings-cpp/blob/19820c39fbbedc1b5f09d6508b5ef1268df3d455/src/serialport_win.cpp#L123-L127
+            // https://github.com/serialport/bindings-cpp/blob/19820c39fbbedc1b5f09d6508b5ef1268df3d455/src/serialport_unix.cpp#L254-L256
+            opts.hupcl = false;
+        }
+
         super(opts, openCallback);
     }