unismsgateway 1.3.2 → 1.4.0

package/README.md

@@ -37,23 +37,24 @@ import { init, getSmsPlatform, reset, smsPlatform } from 'unismsgateway';
 
 | Field        | Type            | Description                            |
 | ------------ | --------------- | -------------------------------------- |
-| `platformId` | `'route'        | 'hubtel'                               |
+| `platformId` | `'route' \| 'hubtel' \| 'nest'` | Which gateway to use. |
 | `param`      | `IgatewayParam` | Provider-specific options (see below). |
 
 
 ### `IgatewayParam` (all fields optional except what your `platformId` requires)
 
 
-| Field          | Type     | Used by         | Description                                                            |
-| -------------- | -------- | --------------- | ---------------------------------------------------------------------- |
-| `username`     | `string` | `route`         | Route Mobile account username. **Required** for `route`.               |
-| `password`     | `string` | `route`         | Route Mobile account password. **Required** for `route`.               |
-| `host`         | `string` | `route`, `nest` | API host. See per-gateway defaults below.                              |
-| `port`         | `number` | `route`         | TCP port for Route Mobile. Default: `8080`.                            |
-| `protocol`     | `'http'  | 'https'`        | `route`, `nest`                                                        |
-| `clientId`     | `string` | `hubtel`        | Hubtel client ID. **Required** for `hubtel`.                           |
-| `clientSecret` | `string` | `hubtel`        | Hubtel client secret. **Required** for `hubtel`.                       |
-| `apiKey`       | `string` | `nest`          | SMSOnlineGH API key (`Authorization: key …`). **Required** for `nest`. |
+| Field          | Type      | Used by         | Description                                                            |
+| -------------- | --------- | --------------- | ---------------------------------------------------------------------- |
+| `username`     | `string`  | `route`         | Route Mobile account username. **Required** for `route`.               |
+| `password`     | `string`  | `route`         | Route Mobile account password. **Required** for `route`.               |
+| `host`         | `string`  | `route`, `nest` | API host. See per-gateway defaults below.                              |
+| `port`         | `number`  | `route`         | TCP port for Route Mobile. Default: `8080`.                            |
+| `protocol`     | `'http' \| 'https'` | `route`, `nest` | HTTPS or HTTP to the provider API.                         |
+| `clientId`     | `string`  | `hubtel`        | Hubtel client ID. **Required** for `hubtel`.                           |
+| `clientSecret` | `string`  | `hubtel`        | Hubtel client secret. **Required** for `hubtel`.                       |
+| `apiKey`       | `string`  | `nest`          | SMSOnlineGH API key (`Authorization: key …`). **Required** for `nest`. |
+| `debug`        | `boolean` | all             | If `true`, the active gateway logs each request/response to the console (prefix `[unismsgateway:…]`). Off by default. |
 
 
 Validation runs in `smsPlatform` when the instance is constructed: missing required fields for the chosen `platformId` throw `Error` with a clear message.
@@ -80,9 +81,9 @@ Nothing is read from the environment unless **you** wire it. Required fields are
 
 | `platformId` | Required in `param`        | Optional in `param` (defaults in this library)                                                |
 | ------------ | -------------------------- | --------------------------------------------------------------------------------------------- |
-| `nest`       | `apiKey`                   | `host` (default `api.smsonlinegh.com`), `protocol` (default `https`)                          |
-| `hubtel`     | `clientId`, `clientSecret` | —                                                                                             |
-| `route`      | `username`, `password`     | `host` (default `rslr.connectbind.com`), `protocol` (default `http`), `port` (default `8080`) |
+| `nest`       | `apiKey`                   | `host` (default `api.smsonlinegh.com`), `protocol` (default `https`), `debug`                 |
+| `hubtel`     | `clientId`, `clientSecret` | `debug`                                                                                       |
+| `route`      | `username`, `password`     | `host` (default `rslr.connectbind.com`), `protocol` (default `http`), `port` (default `8080`), `debug` |
 
 
 **Suggested env names for your app** (optional; you can rename them). Credential keys (`NEST_`*, `HUBTEL_`*, `ROUTE_*`) match [live test](#live-integration-test-environment-variables) and `.env.example`. Platform selection differs: the test script requires `GATEWAY_PLATFORM` (or `TEST_ALL`); in your app you choose any name (the example below uses `SMS_PLATFORM_ID`):
@@ -340,7 +341,7 @@ console.log(balance.balance, balance.model);
 | Field     | Type     | Required | Description                                                            |
 | --------- | -------- | -------- | ---------------------------------------------------------------------- |
 | `From`    | `string` | yes      | Sender ID or label.                                                    |
-| `To`      | `string  | number`  | yes                                                                    |
+| `To`      | `string \| number` | yes                                                                    |
 | `Content` | `string` | yes      | Message body.                                                          |
 | `Type`    | `number` | no       | Message type; **nest** maps this to request body `type` (default `0`). |
 
@@ -357,9 +358,14 @@ Returns `Promise<SendResult>`. Optional `callback` is invoked with the same resu
   messageId?: string;
   data?: any;
   error?: string;
+  statusCode?: number; // HTTP status from the provider when available (nest, etc.)
 }
 ```
 
+When `success` is `false`, always read **`error`** — it contains a human-readable reason (provider status codes, API handshake labels, network errors, and so on). For **`nest`**, if the API rejects the send but returns JSON, **`data`** is the **full parsed response body** (not only `response.data`), so you can inspect `handshake` and any provider fields. For HTTP errors, `data` may be the raw response body string. **`statusCode`** is set when the adapter knows the HTTP status (for example nest).
+
+**Debugging:** Set `param.debug: true` when calling `init()` to print request URLs, bodies, and responses to the console. The live test script enables debug for the `nest` platform so you can trace `quickSend` and `getBalance` without changing application code.
+
 **Example**
 
 ```javascript

package/dist/scripts/test-live.js

@@ -91,8 +91,10 @@ function testPlatform(platformId) {
                     param.apiKey = requireEnv('NEST_API_KEY');
                     if (env('NEST_HOST'))
                         param.host = env('NEST_HOST');
-                    if (env('NEST_PROTOCOL'))
+                    if (env('NEST_PROTOCOL')) {
                         param.protocol = env('NEST_PROTOCOL');
+                    }
+                    param.debug = true;
                     break;
                 case 'hubtel':
                     param.clientId = requireEnv('HUBTEL_CLIENT_ID');
@@ -105,11 +107,12 @@ function testPlatform(platformId) {
                         param.host = env('ROUTE_HOST');
                     if (env('ROUTE_PORT'))
                         param.port = Number(env('ROUTE_PORT'));
-                    if (env('ROUTE_PROTOCOL'))
+                    if (env('ROUTE_PROTOCOL')) {
                         param.protocol = env('ROUTE_PROTOCOL');
+                    }
                     break;
             }
-            platform = (0, lib_1.init)({ platformId, param: param });
+            platform = (0, lib_1.init)({ platformId, param });
             pass(`Initialized ${platformId} platform`);
         }));
         // 2. Balance check (only nest and hubtel expose getBalance)

package/dist/src/lib/hubtel-gateway.d.ts

@@ -2,12 +2,15 @@ import { ISmsGatewayDelegate, QuickSendParams, SendResult } from './types';
 export interface HubtelSmsGatewayConfig {
     clientId: string;
     clientSecret: string;
+    debug?: boolean;
 }
 /**
  * Wraps hubtel-sms-extended and maps API responses to {@link SendResult}.
  */
 export declare class HubtelSmsGateway implements ISmsGatewayDelegate {
     private _client;
+    private _debug;
     constructor(config: HubtelSmsGatewayConfig);
+    private log;
     quickSend(params: QuickSendParams, callback?: Function): Promise<SendResult>;
 }

package/dist/src/lib/hubtel-gateway.js

@@ -16,41 +16,55 @@ const hubtel_sms_extended_1 = require("hubtel-sms-extended");
  */
 class HubtelSmsGateway {
     constructor(config) {
+        this._debug = config.debug || false;
         this._client = new hubtel_sms_extended_1.HubtelSms({
             clientId: config.clientId,
             clientSecret: config.clientSecret
         });
     }
+    log(...args) {
+        if (this._debug) {
+            console.log('[unismsgateway:hubtel]', ...args);
+        }
+    }
     quickSend(params, callback) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
+            this.log('quickSend params:', JSON.stringify(params));
+            let result;
             try {
                 const raw = yield this._client.quickSend({
                     From: params.From,
                     To: String(params.To),
                     Content: params.Content
                 });
-                const ok = Number(raw.Status) === 0;
-                const result = {
+                this.log('quickSend raw response:', JSON.stringify(raw));
+                const ok = Number(raw === null || raw === void 0 ? void 0 : raw.Status) === 0;
+                result = {
                     success: ok,
-                    messageId: String(raw.MessageId),
+                    messageId: (raw === null || raw === void 0 ? void 0 : raw.MessageId) != null ? String(raw.MessageId) : undefined,
                     data: raw,
-                    error: ok ? undefined : `Hubtel Status=${raw.Status}`
+                    error: ok
+                        ? undefined
+                        : `Hubtel API Error: Status=${raw === null || raw === void 0 ? void 0 : raw.Status}, NetworkId=${(_a = raw === null || raw === void 0 ? void 0 : raw.NetworkId) !== null && _a !== void 0 ? _a : 'n/a'}`
                 };
-                if (callback) {
-                    callback(result);
-                }
-                return result;
             }
             catch (error) {
-                const result = {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                this.log('quickSend error:', errorMessage);
+                result = {
                     success: false,
-                    error: error instanceof Error ? error.message : String(error)
+                    error: errorMessage,
+                    data: error instanceof Error && error.response
+                        ? error.response
+                        : null
                 };
-                if (callback) {
-                    callback(result);
-                }
-                return result;
             }
+            this.log('quickSend result:', JSON.stringify(result));
+            if (callback) {
+                callback(result);
+            }
+            return result;
         });
     }
 }

package/dist/src/lib/nest-gateway.d.ts

@@ -3,6 +3,7 @@ export declare class NestSmsGateway implements ISmsGateway {
     private config;
     constructor(config: NestSmsConfig);
     init(): ISmsGateway;
+    private log;
     private makeRequest;
     quickSend(params: QuickSendParams, callback?: Function): Promise<SendResult>;
     getBalance(): Promise<{

package/dist/src/lib/nest-gateway.js

@@ -38,59 +38,80 @@ class NestSmsGateway {
         this.config = {
             host: config.host || DEFAULT_HOST,
             protocol: config.protocol || DEFAULT_PROTOCOL,
-            apiKey: config.apiKey
+            apiKey: config.apiKey,
+            debug: config.debug || false
         };
     }
     init() {
         return this;
     }
+    log(...args) {
+        if (this.config.debug) {
+            console.log('[unismsgateway:nest]', ...args);
+        }
+    }
     makeRequest(endpoint, data) {
         return __awaiter(this, void 0, void 0, function* () {
             return new Promise((resolve, reject) => {
-                var _a;
                 const postData = data ? JSON.stringify(data) : '';
                 const protocol = this.config.protocol || DEFAULT_PROTOCOL;
                 const httpModule = protocol === 'https' ? https : http;
                 const defaultPort = protocol === 'https' ? 443 : 80;
+                const host = this.config.host || DEFAULT_HOST;
+                const hostname = host.includes(':') ? host.split(':')[0] : host;
+                const port = host.includes(':')
+                    ? parseInt(host.split(':')[1], 10)
+                    : defaultPort;
                 const options = {
-                    hostname: this.config.host || DEFAULT_HOST,
-                    port: ((_a = this.config.host) === null || _a === void 0 ? void 0 : _a.includes(':'))
-                        ? parseInt(this.config.host.split(':')[1])
-                        : defaultPort,
+                    hostname,
+                    port,
                     path: `/v5/${endpoint}`,
                     method: 'POST',
                     headers: {
-                        'Host': this.config.host || DEFAULT_HOST,
+                        'Host': hostname,
                         'Content-Type': 'application/json',
                         'Accept': 'application/json',
                         'Authorization': `key ${this.config.apiKey}`,
                         'Content-Length': Buffer.byteLength(postData)
                     }
                 };
+                this.log(`POST /v5/${endpoint}`, data ? JSON.stringify(data) : '(no body)');
                 const req = httpModule.request(options, (res) => {
                     let responseBody = '';
                     res.on('data', (chunk) => {
                         responseBody += chunk;
                     });
                     res.on('end', () => {
+                        var _a;
+                        const statusCode = (_a = res.statusCode) !== null && _a !== void 0 ? _a : 0;
+                        this.log(`HTTP ${statusCode} response:`, responseBody);
                         try {
-                            if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
-                                const parsed = JSON.parse(responseBody);
-                                resolve(parsed);
+                            const parsed = JSON.parse(responseBody);
+                            if (statusCode >= 200 && statusCode < 300) {
+                                resolve({ statusCode, body: parsed });
                             }
                             else {
-                                reject(new Error(`HTTP ${res.statusCode}: ${responseBody}`));
+                                const err = new Error(`HTTP ${statusCode}: ${responseBody}`);
+                                err.statusCode = statusCode;
+                                err.rawBody = responseBody;
+                                reject(err);
                             }
                         }
-                        catch (error) {
-                            reject(new Error(`Failed to parse response: ${responseBody}`));
+                        catch (_b) {
+                            const err = new Error(`Failed to parse gateway response (HTTP ${statusCode}): ${responseBody}`);
+                            err.statusCode = statusCode;
+                            err.rawBody = responseBody;
+                            reject(err);
                         }
                     });
                 });
                 req.on('error', (error) => {
+                    this.log('Network error:', error.message);
                     reject(error);
                 });
-                req.write(postData);
+                if (postData) {
+                    req.write(postData);
+                }
                 req.end();
             });
         });
@@ -98,57 +119,73 @@ class NestSmsGateway {
     quickSend(params, callback) {
         var _a, _b, _c, _d, _e;
         return __awaiter(this, void 0, void 0, function* () {
-            const endpoint = 'message/sms/send';
-            // SMSOnlineGH v5 expects: text, sender, destinations[] (see API docs — not from/to/content).
             const requestBody = {
                 text: params.Content,
-                type: params.Type || 0,
+                type: (_a = params.Type) !== null && _a !== void 0 ? _a : 0,
                 sender: params.From,
                 destinations: [String(params.To)]
             };
+            this.log('quickSend params:', JSON.stringify(params));
+            let result;
             try {
-                const response = yield this.makeRequest(endpoint, requestBody);
-                const handshakeOk = Number((_a = response.handshake) === null || _a === void 0 ? void 0 : _a.id) === 0;
-                const data = (_b = response.data) !== null && _b !== void 0 ? _b : null;
-                const batchId = data && typeof data === 'object' ? data.batch : undefined;
-                const firstDest = data && typeof data === 'object'
-                    ? (_c = data.destinations) === null || _c === void 0 ? void 0 : _c[0]
+                const { statusCode, body: response } = yield this.makeRequest('message/sms/send', requestBody);
+                const handshakeId = (_b = response.handshake) === null || _b === void 0 ? void 0 : _b.id;
+                const handshakeLabel = (_c = response.handshake) === null || _c === void 0 ? void 0 : _c.label;
+                const handshakeOk = Number(handshakeId) === 0;
+                const responseData = (_d = response.data) !== null && _d !== void 0 ? _d : null;
+                const batchId = responseData && typeof responseData === 'object'
+                    ? responseData.batch
+                    : undefined;
+                const firstDest = responseData && typeof responseData === 'object'
+                    ? (_e = responseData.destinations) === null || _e === void 0 ? void 0 : _e[0]
                     : undefined;
-                const result = {
+                let errorMsg;
+                if (!handshakeOk) {
+                    if (handshakeLabel) {
+                        errorMsg = `API Error [code ${handshakeId}]: ${handshakeLabel}`;
+                    }
+                    else if (handshakeId !== undefined && handshakeId !== null) {
+                        errorMsg = `API Error: handshake code=${handshakeId}`;
+                    }
+                    else {
+                        errorMsg = `Unexpected API response: ${JSON.stringify(response)}`;
+                    }
+                }
+                result = {
                     success: handshakeOk,
-                    data,
                     messageId: batchId || (firstDest === null || firstDest === void 0 ? void 0 : firstDest.id),
-                    error: handshakeOk
-                        ? undefined
-                        : (((_d = response.handshake) === null || _d === void 0 ? void 0 : _d.label)
-                            || `handshake id ${String((_e = response.handshake) === null || _e === void 0 ? void 0 : _e.id)}`)
+                    // On failure, expose the full raw response so callers can inspect it.
+                    data: handshakeOk ? responseData : response,
+                    error: errorMsg,
+                    statusCode
                 };
-                if (callback) {
-                    callback(result);
-                }
-                return result;
             }
             catch (error) {
+                const httpErr = error;
                 const errorMessage = error instanceof Error ? error.message : String(error);
-                const result = {
+                result = {
                     success: false,
-                    error: errorMessage
+                    error: errorMessage,
+                    statusCode: httpErr.statusCode,
+                    // Preserve whatever raw body we got for inspection.
+                    data: httpErr.rawBody !== undefined ? httpErr.rawBody : null
                 };
-                if (callback) {
-                    callback(result);
-                }
-                return result;
             }
+            this.log('quickSend result:', JSON.stringify(result));
+            if (callback) {
+                callback(result);
+            }
+            return result;
         });
     }
     getBalance() {
-        var _a, _b;
+        var _a, _b, _c, _d;
         return __awaiter(this, void 0, void 0, function* () {
-            const endpoint = 'account/balance';
-            const response = yield this.makeRequest(endpoint);
+            this.log('getBalance called');
+            const { body: response } = yield this.makeRequest('account/balance');
             return {
-                balance: ((_a = response.data) === null || _a === void 0 ? void 0 : _a.balance) || 0,
-                model: ((_b = response.data) === null || _b === void 0 ? void 0 : _b.model) || 'quantity'
+                balance: (_b = (_a = response.data) === null || _a === void 0 ? void 0 : _a.balance) !== null && _b !== void 0 ? _b : 0,
+                model: (_d = (_c = response.data) === null || _c === void 0 ? void 0 : _c.model) !== null && _d !== void 0 ? _d : 'quantity'
             };
         });
     }

package/dist/src/lib/platform.js

@@ -52,18 +52,21 @@ class smsPlatform {
                     username: param.username,
                     password: param.password,
                     protocol: param.protocol || 'http',
-                    port: param.port || 8080
+                    port: param.port || 8080,
+                    debug: param.debug
                 });
             case 'hubtel':
                 return new hubtel_gateway_1.HubtelSmsGateway({
                     clientId: param.clientId,
-                    clientSecret: param.clientSecret
+                    clientSecret: param.clientSecret,
+                    debug: param.debug
                 });
             case 'nest':
                 return new nest_gateway_1.NestSmsGateway({
                     apiKey: param.apiKey,
                     host: param.host,
-                    protocol: param.protocol
+                    protocol: param.protocol,
+                    debug: param.debug
                 });
             default:
                 throw new Error(`Unsupported platform: ${platformId}`);

package/dist/src/lib/route-gateway.d.ts

@@ -5,8 +5,18 @@ export interface RouteSmsGatewayConfig {
     password: string;
     protocol: 'http' | 'https';
     port: number;
+    debug?: boolean;
 }
+/**
+ * Adapts routemobilesms to {@link ISmsGatewayDelegate}.
+ *
+ * NOTE: routemobilesms stores config in module-level state via the constructor,
+ * then exposes `routeSms.sendAsync` as a static-style call. The instance is
+ * intentionally discarded after construction.
+ */
 export declare class RouteSmsGateway implements ISmsGatewayDelegate {
+    private _debug;
     constructor(config: RouteSmsGatewayConfig);
+    private log;
     quickSend(params: QuickSendParams, callback?: Function): Promise<SendResult>;
 }

package/dist/src/lib/route-gateway.js

@@ -11,9 +11,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RouteSmsGateway = void 0;
 const routemobilesms_1 = require("routemobilesms");
-/**
- * Adapts routemobilesms static `sendAsync` API to {@link ISmsGatewayDelegate}.
- */
 function toRouteDestination(to) {
     if (typeof to === 'number') {
         return to;
@@ -22,8 +19,18 @@ function toRouteDestination(to) {
     const n = Number(digits);
     return Number.isNaN(n) ? 0 : n;
 }
+/**
+ * Adapts routemobilesms to {@link ISmsGatewayDelegate}.
+ *
+ * NOTE: routemobilesms stores config in module-level state via the constructor,
+ * then exposes `routeSms.sendAsync` as a static-style call. The instance is
+ * intentionally discarded after construction.
+ */
 class RouteSmsGateway {
     constructor(config) {
+        this._debug = config.debug || false;
+        // routemobilesms configures itself through its constructor and exposes
+        // sendAsync as a static method — the returned instance is not needed.
         new routemobilesms_1.routeSms({
             host: config.host,
             username: config.username,
@@ -32,8 +39,15 @@ class RouteSmsGateway {
             port: config.port
         });
     }
+    log(...args) {
+        if (this._debug) {
+            console.log('[unismsgateway:route]', ...args);
+        }
+    }
     quickSend(params, callback) {
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
+            this.log('quickSend params:', JSON.stringify(params));
             const sendParams = {
                 From: params.From,
                 To: toRouteDestination(params.To),
@@ -42,24 +56,47 @@ class RouteSmsGateway {
             if (params.Type !== undefined) {
                 sendParams.config = { type: params.Type, dlr: 0 };
             }
-            const raw = yield routemobilesms_1.routeSms.sendAsync(sendParams);
             let result;
-            if (raw === undefined || raw === null) {
-                result = { success: false, error: 'No response from route SMS gateway' };
+            try {
+                const raw = yield routemobilesms_1.routeSms.sendAsync(sendParams);
+                this.log('quickSend raw response:', JSON.stringify(raw));
+                if (raw === undefined || raw === null) {
+                    result = {
+                        success: false,
+                        error: 'No response received from Route SMS gateway',
+                        data: null
+                    };
+                }
+                else if (Array.isArray(raw) && raw.length > 0) {
+                    const first = raw[0];
+                    const ok = first.status === 'successful';
+                    result = {
+                        success: ok,
+                        messageId: first.id,
+                        data: raw,
+                        error: ok
+                            ? undefined
+                            : `Route SMS Error [${(_a = first.code) !== null && _a !== void 0 ? _a : 'unknown'}]: ${(_b = first.message) !== null && _b !== void 0 ? _b : 'Send failed'}`
+                    };
+                }
+                else {
+                    result = {
+                        success: false,
+                        error: 'Unexpected response format from Route SMS gateway',
+                        data: raw
+                    };
+                }
             }
-            else if (Array.isArray(raw) && raw.length > 0) {
-                const first = raw[0];
-                const ok = first.status === 'successful';
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                this.log('quickSend error:', errorMessage);
                 result = {
-                    success: ok,
-                    messageId: first.id,
-                    data: raw,
-                    error: ok ? undefined : (first.message || first.code || 'Send failed')
+                    success: false,
+                    error: errorMessage,
+                    data: null
                 };
             }
-            else {
-                result = { success: false, error: 'Unexpected response from route SMS gateway', data: raw };
-            }
+            this.log('quickSend result:', JSON.stringify(result));
             if (callback) {
                 callback(result);
             }

package/dist/src/lib/types.d.ts

@@ -10,6 +10,8 @@ export interface SendResult {
     messageId?: string;
     data?: any;
     error?: string;
+    /** HTTP status code returned by the gateway (when available). */
+    statusCode?: number;
 }
 export interface IgatewayParam {
     host?: string;
@@ -20,6 +22,8 @@ export interface IgatewayParam {
     clientSecret?: string;
     apiKey?: string;
     protocol?: 'http' | 'https';
+    /** Set to true to print request/response details to console for debugging. */
+    debug?: boolean;
 }
 export interface IgatewaySettings {
     platformId: PlatformId;
@@ -37,6 +41,7 @@ export interface NestSmsConfig {
     apiKey: string;
     host?: string;
     protocol?: 'http' | 'https';
+    debug?: boolean;
 }
 export interface NestSendResponse {
     handshake: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unismsgateway",
-  "version": "1.3.2",
+  "version": "1.4.0",
   "description": "A unified SMS gateway library that brings access to multiple SMS gateways under a single API",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",