icom-wlan-node 0.6.2 → 0.6.3

package/README.md

@@ -132,6 +132,8 @@ await rig.setSplitEnabled(true);
 await rig.setSplitFrequency(7074000);
 await rig.setTuningStep(100);
 await rig.setToneFrequency(88.5);
+await rig.setMode('CW');
+await rig.sendMorse('CQ CQ DE N0CALL');
 await rig.setSpectrumSpeed('slow');
 ```
 
@@ -235,6 +237,7 @@ await rig.disableScope();
   - **Antenna Tuner**: `readTunerStatus()`, `setTunerEnabled()`, `startManualTune()`
   - **Functions**: `getFunction()`, `setFunction()`, plus wrappers for NB/NR/COMP/VOX/MON/ANF/MN/LOCK/BK-IN
   - **Levels**: `getLevel()`, `setLevel()`, plus wrappers for RF gain, IF shift, PBT, CW pitch, key speed, monitor gain, VOX gain
+  - **CW Text**: `sendMorse()`, `sendCwText()`, `stopMorse()` — Hamlib-aligned CI-V `0x17` text handoff to the rig keyer
   - **RIT/XIT + Split/VFO**: `getRitOffset()`, `setRitOffset()`, `getSplitEnabled()`, `setSplitFrequency()`, `getVfo()`, `setVfo()`, `vfoOperation()`
   - **Tone/Tuning**: `getTuningStep()`, `setTuningStep()`, `getToneFrequency()`, `setToneFrequency()`, `getRepeaterShift()`, `setRepeaterOffset()`
   - **Meters (RX)**: `readSquelchStatus()`, `readAudioSquelch()`, `readOvfStatus()`, `getLevelMeter()`
@@ -384,6 +387,8 @@ The library exposes common CI‑V operations as friendly methods. Addresses are
 - `getBreakInMode() => Promise<'off'|'semi'|'full'|null>` / `setBreakInMode(mode)` — Hamlib-aligned BK-IN control using `0x16 0x47`, where raw `1` is semi and raw `2` is full.
 - `getLevel(name: IcomLevelName, options?: QueryOptions) => Promise<number|null>` / `setLevel(name, value)` — Generic level layer for `AF`, `RF`, `SQL`, `IF`, `PBT_IN`, `PBT_OUT`, `CWPITCH`, `KEYSPD`, `NOTCHF_RAW`, `COMP`, `MONITOR_GAIN`, `VOXGAIN`, `ANTIVOX`, and profile ext levels.
 - Common level wrappers: `getRFGain()/setRFGain()`, `getIFShift()/setIFShift()`, `getPbtIn()/setPbtIn()`, `getPbtOut()/setPbtOut()`, `getCwPitch()/setCwPitch()`, `getKeySpeed()/setKeySpeed()`, `getNotchRaw()/setNotchRaw()`, `getCompressionLevel()/setCompressionLevel()`, `getMonitorGain()/setMonitorGain()`, `getVoxGain()/setVoxGain()`, `getAntiVox()/setAntiVox()`.
+- `sendMorse(text, options?)` / `sendCwText(text, options?)` — Send printable ASCII text through the rig's internal CW keyer using CI-V `0x17`; text is uppercased and split into 30-byte chunks by default.
+- `stopMorse(options?)` — Stop the rig CW keyer by sending CI-V `0x17 0xff` and waiting for ACK.
 - `getRitOffset()/setRitOffset()` and `getXitOffset()/setXitOffset()` — RIT/XIT delta register using Hamlib `0x21 0x00`; `getRitEnabled()/setRitEnabled()` and `getXitEnabled()/setXitEnabled()` use `0x21 0x01/0x02`.
 - `getSplitEnabled()/setSplitEnabled()`, `getSplitFrequency()/setSplitFrequency()`, `getSplitMode()/setSplitMode()` — Modern profiles use targetable TX VFO `0x25/0x26` with VFO number `1`.
 - `getVfo()/setVfo()` and `vfoOperation('copy'|'exchange'|'from-vfo'|'to-vfo'|'memory-clear'|'tune')` — Safe Hamlib VFO operation subset.
@@ -391,6 +396,20 @@ The library exposes common CI‑V operations as friendly methods. Addresses are
 - `getToneFrequency()/setToneFrequency(hz)` and `getToneSquelchFrequency()/setToneSquelchFrequency(hz)` — CTCSS values use public Hz, encoded as tenth-Hz BCD BE.
 - `getRepeaterShift()/setRepeaterShift('none'|'minus'|'plus')` and `getRepeaterOffset()/setRepeaterOffset(hz)` — Repeater offset uses public Hz, encoded as 100 Hz units.
 
+#### CW Text Sending
+
+```ts
+await rig.setMode('CW');
+rig.setBreakInMode('semi');
+rig.setKeySpeed(20);
+
+// Sends printable ASCII text to the radio's built-in CW keyer via CI-V 0x17.
+await rig.sendMorse('CQ CQ DE N0CALL', { timeout: 3000 });
+await rig.stopMorse();
+```
+
+`sendMorse()` does not synthesize local Morse audio and does not automatically change mode, PTT, power, or break-in settings. By default it first verifies that the radio reports `CW` or `CW_R`; pass `{ checkMode: false }` only when your application already controls that state. CI-V ACK/NAK replies do not include request IDs, so avoid mixing raw `sendCiv()` write commands that also expect ACKs while a CW text send is in progress.
+
 #### Scope / Spectrum
 
 - `scope: IcomScopeService` — Standalone scope service object that can be reused with other CI‑V transport paths in the future

package/dist/rig/IcomCivSpec.d.ts

@@ -25,6 +25,7 @@ export declare const CIV: {
     readonly C_CTL_LVL: 20;
     readonly C_RD_SQSM: 21;
     readonly C_CTL_FUNC: 22;
+    readonly C_SND_CW: 23;
     readonly C_SET_TONE: 27;
     readonly C_CTL_MEM: 26;
     readonly C_CTL_PTT: 28;

package/dist/rig/IcomCivSpec.js

@@ -28,6 +28,7 @@ exports.CIV = {
     C_CTL_LVL: 0x14,
     C_RD_SQSM: 0x15,
     C_CTL_FUNC: 0x16,
+    C_SND_CW: 0x17,
     C_SET_TONE: 0x1b,
     C_CTL_MEM: 0x1a,
     C_CTL_PTT: 0x1c,

package/dist/rig/IcomControl.d.ts

@@ -1,4 +1,4 @@
-import { IcomRigOptions, RigEventEmitter, IcomMode, ConnectorDataMode, SetModeOptions, QueryOptions, SwrReading, AlcReading, WlanLevelReading, LevelMeterReading, SquelchStatusReading, AudioSquelchReading, OvfStatusReading, PowerLevelReading, CompLevelReading, VoltageReading, CurrentReading, ConnectionState, ConnectionMonitorConfig, ConnectionPhase, ConnectionMetrics, DisconnectReason, DisconnectOptions, TunerStatusReading, LevelReading, IcomScopeSpanInfo, IcomScopeMode, IcomScopeModeInfo, IcomScopeEdgeInfo, IcomScopeFixedEdgeInfo, IcomSpectrumDisplayState, IcomSpectrumDisplayConfig, IcomFunctionName, IcomLevelName, IcomParameterName, IcomVfoName, IcomVfoOperation, IcomRepeaterShift, IcomSpectrumSpeed, IcomSpectrumCenterType, IcomAudioIfSource } from '../types';
+import { IcomRigOptions, RigEventEmitter, IcomMode, ConnectorDataMode, SetModeOptions, SendMorseOptions, QueryOptions, SwrReading, AlcReading, WlanLevelReading, LevelMeterReading, SquelchStatusReading, AudioSquelchReading, OvfStatusReading, PowerLevelReading, CompLevelReading, VoltageReading, CurrentReading, ConnectionState, ConnectionMonitorConfig, ConnectionPhase, ConnectionMetrics, DisconnectReason, DisconnectOptions, TunerStatusReading, LevelReading, IcomScopeSpanInfo, IcomScopeMode, IcomScopeModeInfo, IcomScopeEdgeInfo, IcomScopeFixedEdgeInfo, IcomSpectrumDisplayState, IcomSpectrumDisplayConfig, IcomFunctionName, IcomLevelName, IcomParameterName, IcomVfoName, IcomVfoOperation, IcomRepeaterShift, IcomSpectrumSpeed, IcomSpectrumCenterType, IcomAudioIfSource } from '../types';
 import { IcomCiv } from './IcomCiv';
 import { IcomAudio } from './IcomAudio';
 import { IcomScopeService } from '../scope/IcomScopeService';
@@ -20,6 +20,8 @@ export declare class IcomControl {
     private meterTimer?;
     private activeProfile;
     private lastFilter;
+    private cwQueue;
+    private cwGeneration;
     private connectionSession;
     private nextSessionId;
     private abortHandlers;
@@ -433,6 +435,11 @@ export declare class IcomControl {
     setCwPitch(hz: number): void;
     getKeySpeed(options?: QueryOptions): Promise<number | null>;
     setKeySpeed(wpm: number): void;
+    sendMorse(text: string, options?: SendMorseOptions): Promise<void>;
+    sendCwText(text: string, options?: SendMorseOptions): Promise<void>;
+    stopMorse(options?: {
+        timeout?: number;
+    }): Promise<void>;
     getNotchRaw(options?: QueryOptions): Promise<number | null>;
     setNotchRaw(value: number): void;
     getCompressionLevel(options?: QueryOptions): Promise<number | null>;
@@ -525,6 +532,8 @@ export declare class IcomControl {
     getSpectrumCenterType(options?: QueryOptions): Promise<IcomSpectrumCenterType | null>;
     setSpectrumCenterType(type: IcomSpectrumCenterType): void;
     private unsupported;
+    private enqueueCw;
+    private sendCwFrameAndWaitForAck;
     private readFunctionRaw;
     private writeFunctionRaw;
     private readLevelRaw;
@@ -554,6 +563,8 @@ export declare class IcomControl {
     private static extractTrailingBcd;
     private static matchCommand;
     private static matchCommandFrame;
+    private static matchAckNakFrame;
+    private static normalizeMorseText;
     private waitForCiv;
     static parseFrequencyReply(frame: Buffer, payloadOffsetAfterCommand: number, byteLength?: number): number | null;
     static parseIcomFreqFromReply(frame: Buffer): number | null;

package/dist/rig/IcomControl.js

@@ -150,6 +150,8 @@ class IcomControl {
         this.civAssembleBuf = Buffer.alloc(0); // CIV stream reassembler
         this.activeProfile = (0, IcomProfiles_1.getProfileByModel)('generic-modern-icom');
         this.lastFilter = 1;
+        this.cwQueue = Promise.resolve();
+        this.cwGeneration = 0;
         // Connection state machine (replaces old fragmented state flags)
         this.connectionSession = {
             phase: types_1.ConnectionPhase.IDLE,
@@ -1605,6 +1607,61 @@ class IcomControl {
     setCwPitch(hz) { this.setLevel('CWPITCH', hz); }
     async getKeySpeed(options) { return this.getLevel('KEYSPD', options); }
     setKeySpeed(wpm) { this.setLevel('KEYSPD', wpm); }
+    async sendMorse(text, options = {}) {
+        const normalized = IcomControl.normalizeMorseText(text);
+        if (normalized.length === 0)
+            return;
+        const generation = this.cwGeneration;
+        return this.enqueueCw(async () => {
+            if (generation !== this.cwGeneration)
+                return;
+            if (!this.activeProfile.cw.sendMorse) {
+                throw this.unsupported('SEND_MORSE', 'sendMorse', 'CW text sending is not enabled for active profile');
+            }
+            const timeoutMs = options.timeout ?? 3000;
+            if (options.checkMode !== false) {
+                const mode = await this.readOperatingMode({ timeout: timeoutMs });
+                if (!mode || (mode.mode !== IcomConstants_1.MODE_MAP.CW && mode.mode !== IcomConstants_1.MODE_MAP.CW_R)) {
+                    throw new Error(`CW 0x17 sendMorse requires CW/CW_R mode; current mode is ${mode?.modeName ?? mode?.mode ?? 'unknown'}`);
+                }
+            }
+            const profileMax = Math.max(1, Math.min(30, this.activeProfile.cw.maxChunkLength || 30));
+            const requested = Number.isFinite(options.chunkLength) ? Math.floor(options.chunkLength) : profileMax;
+            const chunkLength = Math.max(1, Math.min(30, profileMax, requested));
+            const interChunkDelayMs = Number.isFinite(options.interChunkDelayMs)
+                ? Math.max(0, Math.floor(options.interChunkDelayMs))
+                : 0;
+            const bytes = Buffer.from(normalized, 'ascii');
+            const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+            const rigAddr = this.civ.civAddress & 0xff;
+            for (let offset = 0, chunkIndex = 1; offset < bytes.length; offset += chunkLength, chunkIndex++) {
+                if (generation !== this.cwGeneration)
+                    return;
+                const chunk = bytes.subarray(offset, Math.min(offset + chunkLength, bytes.length));
+                const frame = IcomRigCommands_1.IcomRigCommands.sendMorseText(ctrAddr, rigAddr, chunk);
+                await this.sendCwFrameAndWaitForAck(frame, timeoutMs, `chunk ${chunkIndex}`);
+                if (generation !== this.cwGeneration)
+                    return;
+                if (interChunkDelayMs > 0 && offset + chunkLength < bytes.length) {
+                    await new Promise((resolve) => setTimeout(resolve, interChunkDelayMs));
+                }
+            }
+        });
+    }
+    sendCwText(text, options) {
+        return this.sendMorse(text, options);
+    }
+    async stopMorse(options = {}) {
+        this.cwGeneration += 1;
+        return this.enqueueCw(async () => {
+            if (!this.activeProfile.cw.sendMorse) {
+                throw this.unsupported('SEND_MORSE', 'stopMorse', 'CW text sending is not enabled for active profile');
+            }
+            const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+            const rigAddr = this.civ.civAddress & 0xff;
+            await this.sendCwFrameAndWaitForAck(IcomRigCommands_1.IcomRigCommands.stopMorse(ctrAddr, rigAddr), options.timeout ?? 3000, 'stop');
+        });
+    }
     async getNotchRaw(options) { return this.getLevel('NOTCHF_RAW', options); }
     setNotchRaw(value) { this.setLevel('NOTCHF_RAW', value); }
     async getCompressionLevel(options) { return this.getLevel('COMP', options); }
@@ -1885,6 +1942,22 @@ class IcomControl {
             reason,
         });
     }
+    enqueueCw(operation) {
+        const run = this.cwQueue.then(operation, operation);
+        this.cwQueue = run.then(() => undefined, () => undefined);
+        return run;
+    }
+    async sendCwFrameAndWaitForAck(frame, timeoutMs, label) {
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        const resp = await this.waitForCivFrame('cw:ack:0x17', (candidate) => IcomControl.matchAckNakFrame(candidate, ctrAddr, rigAddr), timeoutMs, () => this.sendCiv(frame));
+        if (!resp) {
+            throw new Error(`CW 0x17 ${label} ACK timeout`);
+        }
+        if (resp[4] === IcomCivSpec_1.CIV.NAK) {
+            throw new Error(`CW 0x17 ${label} NAK received`);
+        }
+    }
     async readFunctionRaw(name, spec, options) {
         const timeoutMs = options?.timeout ?? 3000;
         const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
@@ -2124,6 +2197,29 @@ class IcomControl {
             return false;
         return true;
     }
+    static matchAckNakFrame(frame, ctrAddr, rigAddr) {
+        if (!(frame.length >= 6 && frame[0] === IcomCivSpec_1.CIV.PR && frame[1] === IcomCivSpec_1.CIV.PR))
+            return false;
+        const addrCtrOk = frame[2] === (ctrAddr & 0xff) || frame[2] === 0x00;
+        if (!addrCtrOk || frame[3] !== (rigAddr & 0xff))
+            return false;
+        if (frame[4] !== IcomCivSpec_1.CIV.ACK && frame[4] !== IcomCivSpec_1.CIV.NAK)
+            return false;
+        return frame[frame.length - 1] === IcomCivSpec_1.CIV.FI;
+    }
+    static normalizeMorseText(text) {
+        if (typeof text !== 'string') {
+            throw new Error('CW 0x17 sendMorse text must be a string');
+        }
+        const normalized = text.toUpperCase().replace(/[\r\n\t]/g, ' ');
+        for (let i = 0; i < normalized.length; i++) {
+            const code = normalized.charCodeAt(i);
+            if (code < 0x20 || code > 0x7e) {
+                throw new Error(`CW 0x17 sendMorse text contains unsupported non-printable or non-ASCII character at index ${i}`);
+            }
+        }
+        return normalized;
+    }
     async waitForCiv(predicate, timeoutMs, onSend) {
         return new Promise((resolve) => {
             let done = false;

package/dist/rig/IcomProfiles.d.ts

@@ -41,6 +41,10 @@ export interface IcomProfile {
     vfos: IcomVfoName[];
     repeater: boolean;
     tone: boolean;
+    cw: {
+        sendMorse: boolean;
+        maxChunkLength: number;
+    };
     spectrumAdvanced: Array<'dataOutput' | 'hold' | 'speed' | 'ref' | 'avg' | 'vbw' | 'rbw' | 'duringTx' | 'centerType'>;
     audioIfSources: IcomAudioIfSource[];
     calibrations: {

package/dist/rig/IcomProfiles.js

@@ -115,6 +115,7 @@ const TARGETABLE_VFOS = ['A', 'B', 'MAIN', 'SUB', 'MAIN_A', 'MAIN_B', 'SUB_A', '
 const COMMON_VFO_OPS = ['copy', 'exchange', 'from-vfo', 'to-vfo', 'memory-clear', 'tune'];
 const IC905_VFO_OPS = ['copy', 'from-vfo', 'to-vfo', 'memory-clear', 'tune'];
 const SPECTRUM_ADVANCED = ['dataOutput', 'hold', 'speed', 'ref', 'avg', 'vbw', 'rbw', 'duringTx', 'centerType'];
+const CW_TEXT_SUPPORTED = { sendMorse: true, maxChunkLength: 30 };
 const TS_IC756PRO = [
     { hz: 10, code: 0x00 },
     { hz: 100, code: 0x01 },
@@ -180,6 +181,7 @@ function baseProfile(overrides) {
         vfos: DEFAULT_VFOS,
         repeater: false,
         tone: false,
+        cw: { sendMorse: false, maxChunkLength: 30 },
         spectrumAdvanced: ['dataOutput', 'hold', 'speed', 'ref', 'vbw', 'duringTx', 'centerType'],
         audioIfSources: ['default'],
         calibrations: {
@@ -289,6 +291,7 @@ exports.ICOM_PROFILES = {
         vfos: DEFAULT_VFOS,
         repeater: true,
         tone: true,
+        cw: CW_TEXT_SUPPORTED,
         spectrumAdvanced: ['dataOutput', 'hold', 'speed', 'ref', 'avg', 'vbw', 'duringTx', 'centerType'],
         audioIfSources: ['default', 'wlan'],
         calibrations: {
@@ -319,6 +322,7 @@ exports.ICOM_PROFILES = {
         vfos: DEFAULT_VFOS,
         repeater: true,
         tone: true,
+        cw: CW_TEXT_SUPPORTED,
         spectrumAdvanced: ['dataOutput', 'hold', 'speed', 'ref', 'avg', 'vbw', 'duringTx', 'centerType'],
         audioIfSources: ['default', 'wlan'],
         calibrations: {
@@ -348,6 +352,7 @@ exports.ICOM_PROFILES = {
         vfos: DEFAULT_VFOS,
         repeater: false,
         tone: true,
+        cw: CW_TEXT_SUPPORTED,
         spectrumAdvanced: ['dataOutput', 'hold', 'speed', 'ref', 'avg', 'vbw', 'duringTx', 'centerType'],
         audioIfSources: ['default'],
         extParams: {
@@ -374,6 +379,7 @@ exports.ICOM_PROFILES = {
         vfos: TARGETABLE_VFOS,
         repeater: true,
         tone: true,
+        cw: CW_TEXT_SUPPORTED,
         spectrumAdvanced: ['dataOutput', 'hold', 'speed', 'ref', 'avg', 'vbw', 'duringTx', 'centerType'],
         audioIfSources: ['default', 'lan', 'acc'],
         extParams: {
@@ -396,6 +402,7 @@ exports.ICOM_PROFILES = {
         vfos: TARGETABLE_VFOS,
         repeater: false,
         tone: true,
+        cw: CW_TEXT_SUPPORTED,
         spectrumAdvanced: SPECTRUM_ADVANCED,
         audioIfSources: ['default'],
         extParams: {
@@ -426,6 +433,7 @@ exports.ICOM_PROFILES = {
         vfos: DEFAULT_VFOS,
         repeater: false,
         tone: true,
+        cw: CW_TEXT_SUPPORTED,
         spectrumAdvanced: [],
         extParamSpecs: {
             ...IC7760_EXT_SPECS,

package/dist/rig/IcomRigCommands.d.ts

@@ -34,6 +34,8 @@ export declare const IcomRigCommands: {
     writeCommand(ctrAddr: number, rigAddr: number, cmd: number, subcmd: number | number[] | undefined, payload?: number[] | Buffer): Buffer;
     readFunction(ctrAddr: number, rigAddr: number, subcmd: number, payload?: number[] | Buffer): Buffer;
     setFunction(ctrAddr: number, rigAddr: number, subcmd: number, value: number, payloadPrefix?: number[]): Buffer;
+    sendMorseText(ctrAddr: number, rigAddr: number, textBytes: Buffer | number[] | string): Buffer;
+    stopMorse(ctrAddr: number, rigAddr: number): Buffer;
     readExtParam(ctrAddr: number, rigAddr: number, command: number, subcmd: number, subext?: number[]): Buffer;
     writeExtParam(ctrAddr: number, rigAddr: number, command: number, subcmd: number, subext?: number[], payload?: number[] | Buffer): Buffer;
     readRitOffset(ctrAddr: number, rigAddr: number): Buffer;

package/dist/rig/IcomRigCommands.js

@@ -116,6 +116,13 @@ exports.IcomRigCommands = {
     setFunction(ctrAddr, rigAddr, subcmd, value, payloadPrefix = []) {
         return (0, IcomCivFrame_1.buildCivFrame)({ rigAddr, ctrlAddr: ctrAddr, cmd: IcomCivSpec_1.CIV.C_CTL_FUNC, subcmd, payload: [...payloadPrefix, value & 0xff] });
     },
+    sendMorseText(ctrAddr, rigAddr, textBytes) {
+        const payload = typeof textBytes === 'string' ? Buffer.from(textBytes, 'ascii') : textBytes;
+        return (0, IcomCivFrame_1.buildCivFrame)({ rigAddr, ctrlAddr: ctrAddr, cmd: IcomCivSpec_1.CIV.C_SND_CW, payload });
+    },
+    stopMorse(ctrAddr, rigAddr) {
+        return (0, IcomCivFrame_1.buildCivFrame)({ rigAddr, ctrlAddr: ctrAddr, cmd: IcomCivSpec_1.CIV.C_SND_CW, payload: [0xff] });
+    },
     readExtParam(ctrAddr, rigAddr, command, subcmd, subext = []) {
         return (0, IcomCivFrame_1.buildCivFrame)({ rigAddr, ctrlAddr: ctrAddr, cmd: command, subcmd, payload: subext });
     },

package/dist/types.d.ts

@@ -91,6 +91,16 @@ export interface SetModeOptions {
     /** Optional IF filter preset. Modern DSP rigs commonly support 1, 2, or 3. */
     filter?: 1 | 2 | 3;
 }
+export interface SendMorseOptions {
+    /** ACK/NAK timeout per CI-V 0x17 chunk. Defaults to 3000 ms. */
+    timeout?: number;
+    /** Maximum text bytes per CI-V 0x17 chunk. Defaults to the active profile limit. */
+    chunkLength?: number;
+    /** Read and require CW/CW_R mode before sending. Defaults to true. */
+    checkMode?: boolean;
+    /** Optional delay between acknowledged chunks. Defaults to 0 ms. */
+    interChunkDelayMs?: number;
+}
 /**
  * Options for query operations (frequency, meters, etc.)
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "icom-wlan-node",
-  "version": "0.6.2",
+  "version": "0.6.3",
   "description": "Icom WLAN (CI‑V, audio) protocol implementation for Node.js/TypeScript.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",