unismsgateway 1.5.3 → 1.6.0

package/README.md

@@ -59,6 +59,7 @@ import { init, getSmsPlatform, reset, smsPlatform } from 'unismsgateway';
 | `timeout`      | `number`           | `nest`          | Request deadline in milliseconds. The request is aborted with an `ETIMEDOUT` error if the server does not respond within this window. Default: `10000`.                                                     |
 | `maxSockets`   | `number`           | `nest`          | Maximum concurrent sockets in the keep-alive pool. Default: `10`.                                                                                                                                           |
 | `retries`      | `number`           | `nest`          | Automatic retry attempts on transient socket errors (`ECONNRESET`, `ECONNABORTED`, `EPIPE`, `ETIMEDOUT`). Default: `1`.                                                                                     |
+| `deliveryCallback` | `{ url: string; accept?: 'application/json' \| 'application/xml' }` | `nest` | Optional SMSOnlineGH [delivery push](https://dev.smsonlinegh.com/docs/v5/http/rest/messaging/delivery_push.html) webhook. When set, every `quickSend` and `send` includes a `callback` block in the send payload. `accept` defaults to `application/json`. Receiving webhook POSTs is your app's responsibility. |
 
 
 Validation runs in `smsPlatform` when the instance is constructed: missing required fields for the chosen `platformId` throw `Error` with a clear message.
@@ -85,7 +86,7 @@ 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`), `debug`, `keepAlive` (default `true`), `timeout` (default `10000` ms), `maxSockets` (default `10`), `retries` (default `1`) |
+| `nest`       | `apiKey`                   | `host` (default `api.smsonlinegh.com`), `protocol` (default `https`), `debug`, `keepAlive` (default `true`), `timeout` (default `10000` ms), `maxSockets` (default `10`), `retries` (default `1`), `deliveryCallback` (optional delivery push webhook) |
 | `hubtel`     | `clientId`, `clientSecret` | `debug`                                                                                                                                                                                           |
 | `route`      | `username`, `password`     | `host` (default `rslr.connectbind.com`), `protocol` (default `http`), `port` (default `8080`), `debug`                                                                                            |
 
@@ -98,6 +99,8 @@ Nothing is read from the environment unless **you** wire it. Required fields are
 | `NEST_API_KEY`         | `apiKey`                   | `nest`                        |
 | `NEST_HOST`            | `host`                     | optional for `nest`           |
 | `NEST_PROTOCOL`        | `protocol`                 | optional for `nest`           |
+| `NEST_DELIVERY_CALLBACK_URL` | `deliveryCallback.url` | optional for `nest`           |
+| `NEST_DELIVERY_CALLBACK_ACCEPT` | `deliveryCallback.accept` | optional for `nest` (`application/json` or `application/xml`; default `application/json`) |
 | `HUBTEL_CLIENT_ID`     | `clientId`                 | `hubtel`                      |
 | `HUBTEL_CLIENT_SECRET` | `clientSecret`             | `hubtel`                      |
 | `ROUTE_USERNAME`       | `username`                 | `route`                       |
@@ -132,7 +135,13 @@ const paramByPlatform = {
   nest: {
     apiKey: process.env.NEST_API_KEY,
     host: process.env.NEST_HOST,
-    protocol: process.env.NEST_PROTOCOL
+    protocol: process.env.NEST_PROTOCOL,
+    deliveryCallback: process.env.NEST_DELIVERY_CALLBACK_URL
+      ? {
+          url: process.env.NEST_DELIVERY_CALLBACK_URL,
+          accept: process.env.NEST_DELIVERY_CALLBACK_ACCEPT
+        }
+      : undefined
   }
 };
 
@@ -167,6 +176,8 @@ The script `scripts/test-live.ts` loads `.env` (copy from `.env.example`) and ex
 | `NEST_API_KEY`  | **Yes**   | Maps to `param.apiKey`.                       |
 | `NEST_HOST`     | No        | Overrides default host `api.smsonlinegh.com`. |
 | `NEST_PROTOCOL` | No        | Overrides default `https`.                    |
+| `NEST_DELIVERY_CALLBACK_URL` | No | Maps to `param.deliveryCallback.url`. When set, sends include SMSOnlineGH delivery push callback info. |
+| `NEST_DELIVERY_CALLBACK_ACCEPT` | No | Maps to `param.deliveryCallback.accept` (`application/json` or `application/xml`; default `application/json`). |
 
 
 `**hubtel`**
@@ -193,12 +204,16 @@ The script `scripts/test-live.ts` loads `.env` (copy from `.env.example`) and ex
 #### Live send (optional; all gateways)
 
 
-| Variable       | Required?                     | Purpose                                                                                                            |
-| -------------- | ----------------------------- | ------------------------------------------------------------------------------------------------------------------ |
-| `TEST_SEND`    | No (default: do not send)     | Set to `true` to call `quickSend()` and send a real SMS. If unset or not `true`, only init and balance checks run. |
-| `TEST_FROM`    | **Yes** when `TEST_SEND=true` | `QuickSendParams.From`.                                                                                            |
-| `TEST_TO`      | **Yes** when `TEST_SEND=true` | `QuickSendParams.To`.                                                                                              |
-| `TEST_CONTENT` | No                            | Message body; if omitted, the script uses a built-in default string.                                               |
+| Variable            | Required?                     | Purpose                                                                                                            |
+| ------------------- | ----------------------------- | ------------------------------------------------------------------------------------------------------------------ |
+| `TEST_SEND`         | No (default: do not send)     | Set to `true` to run live send checks. If unset or not `true`, only init and balance checks run.                   |
+| `TEST_SEND_METHOD`  | No (default: `quickSend`)     | `quickSend` — single recipient via `quickSend()`. `send` — multiple recipients via `send()` (`nest`, `route`). `both` — run both. `sendPersonalized` — personalised bulk via `sendPersonalized()` (`nest` only). |
+| `TEST_FROM`         | **Yes** when `TEST_SEND=true` | Sender ID (`From` / `from`).                                                                                       |
+| `TEST_TO`           | **Yes** when method is `quickSend` or `both` | Single recipient for `quickSend()`. Also used as a one-element array for `send()` when `TEST_TO_MULTI` is omitted. |
+| `TEST_TO_MULTI`     | Recommended for `send` / `both` | Comma-separated MSISDNs for `send()` (e.g. `233...,233...`). Required when `TEST_SEND_METHOD=send` unless `TEST_TO` is set. |
+| `TEST_CONTENT`      | No                            | Message body; if omitted, the script uses a built-in default string.                                               |
+| `TEST_PERSONALIZED_TEMPLATE` | No (default template used) | Message template for `sendPersonalized()` (e.g. `Hello {$name}. Your balance is ${$balance}.`). |
+| `TEST_PERSONALIZED_DESTINATIONS` | **Yes** when `TEST_SEND_METHOD=sendPersonalized` | JSON array of `{ to, values }` objects, e.g. `[{"to":"233...","values":["Name",123]}]`. |
 
 
 ---
@@ -215,7 +230,7 @@ The script `scripts/test-live.ts` loads `.env` (copy from `.env.example`) and ex
   - Calls `createGateway()` to instantiate the underlying provider (`routeSms`, `HubtelSms`, or `NestSmsGateway`).
 3. `**getSmsPlatform(): smsPlatform | null`**: Returns the current singleton, or `null` if `reset()` was called and no new `init()` has run.
 
-There is **no async bootstrap**; after `init()` returns, `quickSend` is ready.
+There is **no async bootstrap**; after `init()` returns, `quickSend`, `send`, and `sendPersonalized` are ready.
 
 ---
 
@@ -312,6 +327,7 @@ const gateway = unisms.init({
 | `timeout`    | `10000`               | Milliseconds before the request is aborted with `ETIMEDOUT`.          |
 | `maxSockets` | `10`                  | Maximum sockets held open in the keep-alive pool.                     |
 | `retries`    | `1`                   | Retry count for transient errors (`ECONNRESET`, `ECONNABORTED`, etc). |
+| `deliveryCallback` | — | Optional delivery push webhook. When set, each send request includes `callback: { url, accept }` per [SMSOnlineGH delivery push docs](https://dev.smsonlinegh.com/docs/v5/http/rest/messaging/delivery_push.html). `accept` defaults to `application/json`. This library registers the URL with the provider only; your app must expose and handle the webhook endpoint. |
 
 
 Requests use `POST` to path `/v5/<endpoint>` (e.g. send: `message/sms/send`, balance: `account/balance`). Authorization header: `Authorization: key <apiKey>`.
@@ -330,6 +346,113 @@ const gateway = unisms.init({
 gateway.getGateway().destroy();
 ```
 
+**Example with delivery push callback:**
+
+```javascript
+const gateway = unisms.init({
+  platformId: 'nest',
+  param: {
+    apiKey: 'your-api-key',
+    deliveryCallback: {
+      url: 'https://your-app.example/sms/delivery',
+      accept: 'application/json' // optional; default application/json
+    }
+  }
+});
+```
+
+SMSOnlineGH POSTs delivery status to that URL asynchronously after the operator reports delivery. The initial `quickSend` response still only reflects submission status.
+
+**Delivery push callback payload**
+
+A delivery push notification uses the same response shape as a [Message Delivery Report](https://dev.smsonlinegh.com/docs/v5/http/rest/messaging/delivery_report.html), but applies to **one destination only**. Expect a single item in `data.destinations` (even when the original send had multiple recipients).
+
+The `Content-Type` of the POST matches your configured `deliveryCallback.accept` (`application/json` by default, or `application/xml`).
+
+**JSON** (`accept: 'application/json'`):
+
+```json
+{
+  "handshake": {
+    "id": 0,
+    "label": "HSHK_OK"
+  },
+  "data": {
+    "batch": "cfa19ba67f94fbd6b19c067b0c87ed4f",
+    "delivery": true,
+    "category": "sms",
+    "text": "Hello world!",
+    "type": 0,
+    "sender": "Hello",
+    "personalised": false,
+    "destinationsCount": 2,
+    "destinations": [
+      {
+        "to": "233246314915",
+        "id": "093841e5-578a-41f4-5f5f-2f3910886c12",
+        "country": "Ghana",
+        "messageCount": 1,
+        "submitDateTime": "2021-09-29 21:57:44",
+        "reportDateTime": "2021-09-29 21:57:48",
+        "status": {
+          "id": 2110,
+          "label": "DS_DELIVERED"
+        }
+      }
+    ]
+  }
+}
+```
+
+**XML** (`accept: 'application/xml'`):
+
+```xml
+<response>
+  <handshake>
+    <id>0</id>
+    <label>HSHK_OK</label>
+  </handshake>
+  <data>
+    <batch>cfa19ba67f94fbd6b19c067b0c87ed4f</batch>
+    <category>sms</category>
+    <delivery>true</delivery>
+    <text>Hello world!</text>
+    <type>0</type>
+    <sender>Hello</sender>
+    <personalised>false</personalised>
+    <destinationsCount>2</destinationsCount>
+    <destinations>
+      <item>
+        <to>233246314915</to>
+        <id>093841e5-578a-41f4-5f5f-2f3910886c12</id>
+        <country>Ghana</country>
+        <messageCount>1</messageCount>
+        <submitDateTime>2021-09-29 21:57:44</submitDateTime>
+        <reportDateTime>2021-09-29 21:57:48</reportDateTime>
+        <status>
+          <id>2110</id>
+          <label>DS_DELIVERED</label>
+        </status>
+      </item>
+    </destinations>
+  </data>
+</response>
+```
+
+Fields your webhook handler will typically use:
+
+| Path | Description |
+| ---- | ----------- |
+| `handshake.label` | `HSHK_OK` when the payload is valid. |
+| `data.batch` | Batch ID from the original send (matches `SendResult.messageId` / `data.batch` from `quickSend`). |
+| `data.destinations[0].to` | Recipient phone number for this delivery event. |
+| `data.destinations[0].id` | Per-destination message ID. |
+| `data.destinations[0].status.id` / `status.label` | Delivery outcome (e.g. `2110` / `DS_DELIVERED`). |
+| `data.destinations[0].submitDateTime` | When the message was submitted to the operator. |
+| `data.destinations[0].reportDateTime` | When the operator reported this delivery status. |
+
+Respond with HTTP `200` promptly so SMSOnlineGH does not retry the push. Persist and process the payload asynchronously if your handler does heavy work.
+
 **Example with performance tuning:**
 
 ```javascript
@@ -361,6 +484,8 @@ console.log(balance.balance, balance.model);
 
 ## Sending messages
 
+Use **`quickSend()`** for a single recipient. Use **`send()`** when the active gateway supports batch delivery to multiple numbers in one request (`nest`, `route`). Use **`sendPersonalized()`** when each recipient needs a customised message from one template (`nest` only). **`hubtel`** does not support `send()` or `sendPersonalized()` — call `quickSend()` per recipient instead.
+
 ### `QuickSendParams`
 
 
@@ -392,7 +517,7 @@ Returns `Promise<SendResult>`. Optional `callback` is invoked with the same resu
 
 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.
+**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`, `send`, and `getBalance` without changing application code.
 
 **Example**
 
@@ -435,6 +560,102 @@ gateway.quickSend(
 );
 ```
 
+### `SendParams`
+
+Same fields as `QuickSendParams`, except `To` is an array of recipients:
+
+
+| Field     | Type                    | Required | Description                                                            |
+| --------- | ----------------------- | -------- | ---------------------------------------------------------------------- |
+| `From`    | `string`                | yes      | Sender ID or label.                                                    |
+| `To`      | `(string \| number)[]`  | yes      | One or more recipient MSISDNs or numbers.                              |
+| `Content` | `string`                | yes      | Message body (same content to all recipients).                         |
+| `Type`    | `number`                | no       | Message type; **nest** maps this to request body `type` (default `0`). |
+
+
+**camelCase:** Pass `{ from, to, content, type? }` where `to` is an array. See `normalizeSendParams`.
+
+**Platform behaviour**
+
+| Platform | `send()` support | Notes |
+| -------- | ---------------- | ----- |
+| `nest`   | Yes              | One HTTP request with `destinations: string[]`. `messageId` is the batch ID; per-recipient status is in `data.destinations`. |
+| `route`  | Yes              | Passes `To` as `number[]` to Route Mobile. `success` is true only when every destination succeeds; partial failures set `error` with a summary. |
+| `hubtel` | No               | Throws — use `quickSend()` for each recipient. |
+
+### `send(params, callback?)`
+
+Returns `Promise<SendResult>`. Same result shape and callback semantics as `quickSend`. Accepts `SendParams` (PascalCase) or `SendParamsCamel` (`{ from, to: [...], content, type? }`).
+
+**Example (`nest`)**
+
+```javascript
+const result = await gateway.send({
+  From: 'TEST',
+  To: ['0246314915', '0242053072'],
+  Content: 'Hello from unismsgateway!',
+  Type: 0
+});
+
+if (result.success) {
+  console.log('Batch:', result.messageId);
+  console.log('Destinations:', result.data?.destinations);
+}
+```
+
+### Personalized bulk send
+
+Use **`sendPersonalized()`** when each recipient should receive a **different** message body derived from one template. Placeholders in the template use SMSOnlineGH variable syntax (`{$name}`, `${$balance}`, etc.); per-recipient substitution values are passed as positional arrays in the same order variables appear in the template. See [SMSOnlineGH Personalised Messaging](https://dev.smsonlinegh.com/docs/v5/http/rest/messaging/sms_personalised.html?tabs=json%2Ctabid-1).
+
+### `PersonalizedSendParams`
+
+| Field           | Type                      | Required | Description                                                                 |
+| --------------- | ------------------------- | -------- | --------------------------------------------------------------------------- |
+| `From`          | `string`                  | yes      | Sender ID or label.                                                         |
+| `Content`       | `string`                  | yes      | Message template with `{$variable}` placeholders.                           |
+| `Destinations`  | `PersonalizedRecipient[]` | yes      | One entry per recipient with `To` and positional `Values`.                  |
+| `Type`          | `number`                  | no       | Message type; **nest** maps this to request body `type` (default `0`).      |
+
+Each `PersonalizedRecipient`:
+
+| Field    | Type                    | Required | Description                                      |
+| -------- | ----------------------- | -------- | ------------------------------------------------ |
+| `To`     | `string \| number`      | yes      | Recipient MSISDN or number.                      |
+| `Values` | `(string \| number)[]`  | yes      | Substitution values in template variable order.  |
+
+**camelCase:** Pass `{ from, content, destinations: [{ to, values }], type? }`. See `normalizePersonalizedSendParams`.
+
+**Platform behaviour**
+
+| Platform | `sendPersonalized()` support | Notes |
+| -------- | ---------------------------- | ----- |
+| `nest`   | Yes                          | One HTTP request with `destinations: [{ number, values }]`. Same endpoint as `send()`; `messageId` is the batch ID; per-recipient status is in `data.destinations`. |
+| `route`  | No                           | Throws — use `send()` with the same content for all recipients. |
+| `hubtel` | No                           | Throws — use `quickSend()` per recipient. |
+
+### `sendPersonalized(params, callback?)`
+
+Returns `Promise<SendResult>`. Same result shape and callback semantics as `send`. Accepts `PersonalizedSendParams` (PascalCase) or `PersonalizedSendParamsCamel`.
+
+**Example (`nest`)**
+
+```javascript
+const result = await gateway.sendPersonalized({
+  From: 'TEST',
+  Content: 'Hello {$name}. Your balance is ${$balance}.',
+  Destinations: [
+    { To: '0246314915', Values: ['Daniel', 560.45] },
+    { To: '0242053072', Values: ['Emmanuel', 348.56] }
+  ],
+  Type: 0
+});
+
+if (result.success) {
+  console.log('Batch:', result.messageId);
+  console.log('Destinations:', result.data?.destinations);
+}
+```
+
 ---
 
 ## Testing (live integration)
@@ -457,7 +678,7 @@ npm run test:live
 
 1. **Init** — Builds `param` from your `.env`, calls `init()`, and checks configuration validation.
 2. **Balance** — For `nest` and `hubtel` only, calls `getBalance()` when the adapter supports it. `route` skips this step.
-3. **Send** — **Opt-in.** By default no SMS is sent. Set `TEST_SEND=true` and the send-related variables listed in [Live integration test environment variables](#live-integration-test-environment-variables).
+3. **Send** — **Opt-in.** By default no SMS is sent. Set `TEST_SEND=true` and the send-related variables listed in [Live integration test environment variables](#live-integration-test-environment-variables). Use `TEST_SEND_METHOD` to choose `quickSend` (default), `send` (multi-destination on `nest`/`route`), `both`, or `sendPersonalized` (`nest` only). For `hubtel`, the script verifies that `send()` is rejected as expected; for `route`/`hubtel`, `sendPersonalized()` rejection is verified when that method is selected.
 
 Full variable reference (selection, per-gateway credentials, live send): [Live integration test environment variables](#live-integration-test-environment-variables). The script loads `.env` via `dotenv` (dev dependency). Exit code is `0` when all checks pass, non-zero if a step fails or no platform is selected.
 
@@ -475,6 +696,13 @@ Full variable reference (selection, per-gateway credentials, live send): [Live i
 | `QuickSendParamsInput`     | Union: PascalCase `QuickSendParams` or camelCase `QuickSendParamsCamel`.   |
 | `QuickSendParamsCamel`     | `{ from, to, content, type? }` for `quickSend`.                            |
 | `normalizeQuickSendParams` | Maps input to canonical `QuickSendParams` (throws if body/sender missing). |
+| `SendParamsInput`          | Union: PascalCase `SendParams` or camelCase `SendParamsCamel`.             |
+| `SendParamsCamel`          | `{ from, to: (string\|number)[], content, type? }` for `send`.             |
+| `normalizeSendParams`      | Maps input to canonical `SendParams` (throws if body/sender/recipients missing). |
+| `PersonalizedSendParamsInput` | Union: PascalCase `PersonalizedSendParams` or camelCase `PersonalizedSendParamsCamel`. |
+| `PersonalizedSendParamsCamel` | `{ from, content, destinations: [{ to, values }], type? }` for `sendPersonalized`. |
+| `PersonalizedRecipient`    | `{ To, Values }` — one personalised destination. |
+| `normalizePersonalizedSendParams` | Maps input to canonical `PersonalizedSendParams` (throws if template/sender/destinations missing). |
 
 
 `**smsPlatform` instance methods**
@@ -483,7 +711,9 @@ Full variable reference (selection, per-gateway credentials, live send): [Live i
 | Method                         | Returns               | Description                                                                      |
 | ------------------------------ | --------------------- | -------------------------------------------------------------------------------- |
 | `init()`                       | `ISmsGateway`         | Returns `this` (facade).                                                         |
-| `quickSend(params, callback?)` | `Promise<SendResult>` | Normalizes PascalCase or camelCase params, then delegates to the active gateway. |
+| `quickSend(params, callback?)` | `Promise<SendResult>` | Single recipient. Normalizes PascalCase or camelCase params.                     |
+| `send(params, callback?)`      | `Promise<SendResult>` | Multiple recipients (`To` array). Supported on `nest` and `route`; `hubtel` throws. |
+| `sendPersonalized(params, callback?)` | `Promise<SendResult>` | Personalised bulk send (`Destinations` with per-recipient `Values`). Supported on `nest` only; `route` and `hubtel` throw. |
 | `getGateway()`                 | `ISmsGateway`         | Underlying adapter (for nest: `getBalance()`).                                   |
 
 
@@ -493,6 +723,8 @@ Full variable reference (selection, per-gateway credentials, live send): [Live i
 
 ### 1.6.0
 
+- **New:** `sendPersonalized()` for personalised bulk SMS on **`nest`** (SMSOnlineGH template variables + per-destination `values`). **`route`** and **`hubtel`** throw — use `send()` or `quickSend()` instead.
+- **New:** `send()` for multi-destination SMS on **`nest`** (SMSOnlineGH `destinations` array) and **`route`** (Route Mobile `number[]`). `To` is `(string | number)[]`. **`hubtel`** throws — use `quickSend()` per recipient.
 - **Performance (`nest`):** The `NestSmsGateway` now uses a persistent keep-alive connection pool (`https.Agent`) instead of opening a fresh TCP + TLS connection on every request. Subsequent sends to the same host reuse warm sockets, eliminating the per-call handshake overhead (~100–300 ms per request).
 - **Reliability (`nest`):** Stale-socket errors (`ECONNRESET`, `ECONNABORTED`, `EPIPE`, `ETIMEDOUT`) that can occur when a pooled socket is reused after the server has closed it are automatically retried on a fresh connection. The default retry count is `1`; configure via `param.retries`.
 - **Timeout support (`nest`):** Requests that stall mid-flight are now aborted after a configurable deadline (`param.timeout`, default `10 000 ms`) instead of hanging indefinitely.

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

@@ -1,4 +1,4 @@
-import { ISmsGatewayDelegate, QuickSendParams, SendResult } from './types';
+import { ISmsGatewayDelegate, QuickSendParams, SendParams, PersonalizedSendParams, SendResult } from './types';
 export interface HubtelSmsGatewayConfig {
     clientId: string;
     clientSecret: string;
@@ -13,4 +13,6 @@ export declare class HubtelSmsGateway implements ISmsGatewayDelegate {
     constructor(config: HubtelSmsGatewayConfig);
     private log;
     quickSend(params: QuickSendParams, callback?: Function): Promise<SendResult>;
+    send(_params: SendParams, _callback?: Function): Promise<SendResult>;
+    sendPersonalized(_params: PersonalizedSendParams, _callback?: Function): Promise<SendResult>;
 }

package/dist/lib/hubtel-gateway.js

@@ -67,5 +67,15 @@ class HubtelSmsGateway {
             return result;
         });
     }
+    send(_params, _callback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error('Hubtel does not support send() with multiple destinations. Use quickSend() for a single recipient.');
+        });
+    }
+    sendPersonalized(_params, _callback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error('Hubtel does not support sendPersonalized(). Use quickSend() for a single recipient.');
+        });
+    }
 }
 exports.HubtelSmsGateway = HubtelSmsGateway;

package/dist/lib/lib.d.ts

@@ -1,5 +1,5 @@
-import { smsPlatform, IgatewaySettings, IgatewayParam, PlatformId, QuickSendParams, QuickSendParamsInput, QuickSendParamsCamel, normalizeQuickSendParams, SendResult, ISmsGateway } from './platform';
+import { smsPlatform, IgatewaySettings, IgatewayParam, PlatformId, QuickSendParams, QuickSendParamsInput, QuickSendParamsCamel, normalizeQuickSendParams, SendParams, SendParamsInput, SendParamsCamel, normalizeSendParams, PersonalizedSendParams, PersonalizedSendParamsInput, PersonalizedSendParamsCamel, PersonalizedRecipient, normalizePersonalizedSendParams, SendResult, ISmsGateway } from './platform';
 export declare function init(settings: IgatewaySettings): smsPlatform;
 export declare function getSmsPlatform(): smsPlatform | null;
 export declare function reset(): void;
-export { smsPlatform, IgatewaySettings, IgatewayParam, PlatformId, QuickSendParams, QuickSendParamsInput, QuickSendParamsCamel, normalizeQuickSendParams, SendResult, ISmsGateway };
+export { smsPlatform, IgatewaySettings, IgatewayParam, PlatformId, QuickSendParams, QuickSendParamsInput, QuickSendParamsCamel, normalizeQuickSendParams, SendParams, SendParamsInput, SendParamsCamel, normalizeSendParams, PersonalizedSendParams, PersonalizedSendParamsInput, PersonalizedSendParamsCamel, PersonalizedRecipient, normalizePersonalizedSendParams, SendResult, ISmsGateway };

package/dist/lib/lib.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeQuickSendParams = exports.smsPlatform = exports.reset = exports.getSmsPlatform = exports.init = void 0;
+exports.normalizePersonalizedSendParams = exports.normalizeSendParams = exports.normalizeQuickSendParams = exports.smsPlatform = exports.reset = exports.getSmsPlatform = exports.init = void 0;
 const platform_1 = require("./platform");
 Object.defineProperty(exports, "smsPlatform", { enumerable: true, get: function () { return platform_1.smsPlatform; } });
 Object.defineProperty(exports, "normalizeQuickSendParams", { enumerable: true, get: function () { return platform_1.normalizeQuickSendParams; } });
+Object.defineProperty(exports, "normalizeSendParams", { enumerable: true, get: function () { return platform_1.normalizeSendParams; } });
+Object.defineProperty(exports, "normalizePersonalizedSendParams", { enumerable: true, get: function () { return platform_1.normalizePersonalizedSendParams; } });
 let smsPlatformInstance = null;
 function init(settings) {
     smsPlatformInstance = new platform_1.smsPlatform(settings);

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

@@ -1,4 +1,4 @@
-import { ISmsGateway, QuickSendParams, SendResult, NestSmsConfig } from './types';
+import { ISmsGateway, QuickSendParams, SendParams, PersonalizedSendParams, SendResult, NestSmsConfig } from './types';
 export declare class NestSmsGateway implements ISmsGateway {
     private readonly _cfg;
     private _agent;
@@ -50,6 +50,12 @@ export declare class NestSmsGateway implements ISmsGateway {
      */
     private makeRequest;
     quickSend(params: QuickSendParams, callback?: Function): Promise<SendResult>;
+    send(params: SendParams, callback?: Function): Promise<SendResult>;
+    sendPersonalized(params: PersonalizedSendParams, callback?: Function): Promise<SendResult>;
+    private _buildMessageRequestBody;
+    private _buildPersonalizedMessageRequestBody;
+    private _parseNestSendResponse;
+    private _sendToDestinations;
     getBalance(): Promise<{
         balance: number;
         model: string;

package/dist/lib/nest-gateway.js

@@ -58,7 +58,8 @@ class NestSmsGateway {
             timeout: (_a = config.timeout) !== null && _a !== void 0 ? _a : DEFAULT_TIMEOUT,
             maxSockets: (_b = config.maxSockets) !== null && _b !== void 0 ? _b : DEFAULT_MAX_SOCKETS,
             retries: (_c = config.retries) !== null && _c !== void 0 ? _c : DEFAULT_RETRIES,
-            keepAlive: config.keepAlive !== false
+            keepAlive: config.keepAlive !== false,
+            deliveryCallback: config.deliveryCallback
         };
         this._agent = this._createAgent();
     }
@@ -211,48 +212,117 @@ class NestSmsGateway {
         });
     }
     quickSend(params, callback) {
-        var _a, _b, _c, _d, _e;
         return __awaiter(this, void 0, void 0, function* () {
-            const requestBody = {
-                text: params.Content,
-                type: (_a = params.Type) !== null && _a !== void 0 ? _a : 0,
-                sender: params.From,
-                destinations: [String(params.To)]
-            };
-            this.log('quickSend params:', JSON.stringify(params));
+            return this._sendToDestinations([String(params.To)], params.From, params.Content, params.Type, callback, 'quickSend', params);
+        });
+    }
+    send(params, callback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._sendToDestinations(params.To.map(String), params.From, params.Content, params.Type, callback, 'send', params);
+        });
+    }
+    sendPersonalized(params, callback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestBody = this._buildPersonalizedMessageRequestBody(params.Destinations, params.From, params.Content, params.Type);
+            this.log('sendPersonalized params:', JSON.stringify(params));
             let result;
             try {
                 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;
-                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 = this._parseNestSendResponse(statusCode, response);
+            }
+            catch (error) {
+                const httpErr = error;
+                const errorMessage = error instanceof Error ? error.message : String(error);
                 result = {
-                    success: handshakeOk,
-                    messageId: batchId || (firstDest === null || firstDest === void 0 ? void 0 : firstDest.id),
-                    data: handshakeOk ? responseData : response,
-                    error: errorMsg,
-                    statusCode
+                    success: false,
+                    error: errorMessage,
+                    statusCode: httpErr.statusCode,
+                    data: httpErr.rawBody !== undefined ? httpErr.rawBody : null
                 };
             }
+            this.log('sendPersonalized result:', JSON.stringify(result));
+            if (callback) {
+                callback(result);
+            }
+            return result;
+        });
+    }
+    _buildMessageRequestBody(destinations, from, content, type) {
+        var _a, _b;
+        const requestBody = {
+            text: content,
+            type: type !== null && type !== void 0 ? type : 0,
+            sender: from,
+            destinations
+        };
+        if ((_a = this._cfg.deliveryCallback) === null || _a === void 0 ? void 0 : _a.url) {
+            requestBody.callback = {
+                url: this._cfg.deliveryCallback.url,
+                accept: (_b = this._cfg.deliveryCallback.accept) !== null && _b !== void 0 ? _b : 'application/json'
+            };
+        }
+        return requestBody;
+    }
+    _buildPersonalizedMessageRequestBody(destinations, from, content, type) {
+        var _a, _b;
+        const requestBody = {
+            text: content,
+            type: type !== null && type !== void 0 ? type : 0,
+            sender: from,
+            destinations: destinations.map(d => ({
+                number: String(d.To),
+                values: d.Values
+            }))
+        };
+        if ((_a = this._cfg.deliveryCallback) === null || _a === void 0 ? void 0 : _a.url) {
+            requestBody.callback = {
+                url: this._cfg.deliveryCallback.url,
+                accept: (_b = this._cfg.deliveryCallback.accept) !== null && _b !== void 0 ? _b : 'application/json'
+            };
+        }
+        return requestBody;
+    }
+    _parseNestSendResponse(statusCode, response) {
+        var _a, _b, _c, _d;
+        const handshakeId = (_a = response.handshake) === null || _a === void 0 ? void 0 : _a.id;
+        const handshakeLabel = (_b = response.handshake) === null || _b === void 0 ? void 0 : _b.label;
+        const handshakeOk = Number(handshakeId) === 0;
+        const responseData = (_c = response.data) !== null && _c !== void 0 ? _c : null;
+        const batchId = responseData && typeof responseData === 'object'
+            ? responseData.batch
+            : undefined;
+        const firstDest = responseData && typeof responseData === 'object'
+            ? (_d = responseData.destinations) === null || _d === void 0 ? void 0 : _d[0]
+            : undefined;
+        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)}`;
+            }
+        }
+        return {
+            success: handshakeOk,
+            messageId: batchId || (firstDest === null || firstDest === void 0 ? void 0 : firstDest.id),
+            data: handshakeOk ? responseData : response,
+            error: errorMsg,
+            statusCode
+        };
+    }
+    _sendToDestinations(destinations, from, content, type, callback, logLabel, logParams) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestBody = this._buildMessageRequestBody(destinations, from, content, type);
+            this.log(`${logLabel} params:`, JSON.stringify(logParams));
+            let result;
+            try {
+                const { statusCode, body: response } = yield this.makeRequest('message/sms/send', requestBody);
+                result = this._parseNestSendResponse(statusCode, response);
+            }
             catch (error) {
                 const httpErr = error;
                 const errorMessage = error instanceof Error ? error.message : String(error);
@@ -263,7 +333,7 @@ class NestSmsGateway {
                     data: httpErr.rawBody !== undefined ? httpErr.rawBody : null
                 };
             }
-            this.log('quickSend result:', JSON.stringify(result));
+            this.log(`${logLabel} result:`, JSON.stringify(result));
             if (callback) {
                 callback(result);
             }

package/dist/lib/platform.d.ts

@@ -1,13 +1,16 @@
-import { IgatewaySettings, IgatewayParam, ISmsGateway, ISmsGatewayDelegate, QuickSendParamsInput, SendResult } from './types';
+import { IgatewaySettings, IgatewayParam, ISmsGateway, ISmsGatewayDelegate, QuickSendParamsInput, SendParamsInput, SendResult, PersonalizedSendParamsInput } from './types';
 export * from './types';
 export declare class smsPlatform implements ISmsGateway {
     private _settings;
     private _gateway;
     constructor(settings: IgatewaySettings);
     private validateSettings;
+    private validateNestDeliveryCallback;
     private createGateway;
     init(): ISmsGateway;
     quickSend(param: QuickSendParamsInput, callback?: Function): Promise<SendResult>;
+    send(param: SendParamsInput, callback?: Function): Promise<SendResult>;
+    sendPersonalized(param: PersonalizedSendParamsInput, callback?: Function): Promise<SendResult>;
     getGateway(): ISmsGatewayDelegate;
 }
 export { IgatewaySettings, IgatewayParam };

package/dist/lib/platform.js

@@ -43,6 +43,21 @@ class smsPlatform {
         if (config.requiresUsernamePassword && (!param.username || !param.password)) {
             throw new Error(`Platform '${settings.platformId}' requires 'username' and 'password' in param`);
         }
+        if (settings.platformId === 'nest' && param.deliveryCallback) {
+            this.validateNestDeliveryCallback(param.deliveryCallback);
+        }
+    }
+    validateNestDeliveryCallback(deliveryCallback) {
+        const url = deliveryCallback.url == null ? '' : String(deliveryCallback.url).trim();
+        if (url === '') {
+            throw new Error("Platform 'nest': deliveryCallback.url must be a non-empty string");
+        }
+        const accept = deliveryCallback.accept;
+        if (accept !== undefined &&
+            accept !== 'application/json' &&
+            accept !== 'application/xml') {
+            throw new Error("Platform 'nest': deliveryCallback.accept must be 'application/json' or 'application/xml'");
+        }
     }
     createGateway() {
         const { platformId, param } = this._settings;
@@ -71,7 +86,13 @@ class smsPlatform {
                     timeout: param.timeout,
                     maxSockets: param.maxSockets,
                     retries: param.retries,
-                    keepAlive: param.keepAlive
+                    keepAlive: param.keepAlive,
+                    deliveryCallback: param.deliveryCallback
+                        ? {
+                            url: param.deliveryCallback.url.trim(),
+                            accept: param.deliveryCallback.accept
+                        }
+                        : undefined
                 });
             default:
                 throw new Error(`Unsupported platform: ${platformId}`);
@@ -87,6 +108,20 @@ class smsPlatform {
         const normalized = (0, types_1.normalizeQuickSendParams)(param);
         return this._gateway.quickSend(normalized, callback);
     }
+    send(param, callback) {
+        if (!this._gateway) {
+            throw new Error('Gateway not initialized. Call init() first.');
+        }
+        const normalized = (0, types_1.normalizeSendParams)(param);
+        return this._gateway.send(normalized, callback);
+    }
+    sendPersonalized(param, callback) {
+        if (!this._gateway) {
+            throw new Error('Gateway not initialized. Call init() first.');
+        }
+        const normalized = (0, types_1.normalizePersonalizedSendParams)(param);
+        return this._gateway.sendPersonalized(normalized, callback);
+    }
     getGateway() {
         return this._gateway;
     }

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

@@ -1,4 +1,4 @@
-import { ISmsGatewayDelegate, QuickSendParams, SendResult } from './types';
+import { ISmsGatewayDelegate, QuickSendParams, SendParams, PersonalizedSendParams, SendResult } from './types';
 export interface RouteSmsGatewayConfig {
     host: string;
     username: string;
@@ -19,4 +19,7 @@ export declare class RouteSmsGateway implements ISmsGatewayDelegate {
     constructor(config: RouteSmsGatewayConfig);
     private log;
     quickSend(params: QuickSendParams, callback?: Function): Promise<SendResult>;
+    send(params: SendParams, callback?: Function): Promise<SendResult>;
+    private _send;
+    sendPersonalized(_params: PersonalizedSendParams, _callback?: Function): Promise<SendResult>;
 }

package/dist/lib/route-gateway.js

@@ -19,6 +19,9 @@ function toRouteDestination(to) {
     const n = Number(digits);
     return Number.isNaN(n) ? 0 : n;
 }
+function toRouteDestinations(to) {
+    return to.map(toRouteDestination);
+}
 /**
  * Adapts routemobilesms to {@link ISmsGatewayDelegate}.
  *
@@ -45,21 +48,31 @@ class RouteSmsGateway {
         }
     }
     quickSend(params, callback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._send([toRouteDestination(params.To)], params.From, params.Content, params.Type, callback, 'quickSend', params);
+        });
+    }
+    send(params, callback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._send(toRouteDestinations(params.To), params.From, params.Content, params.Type, callback, 'send', params);
+        });
+    }
+    _send(destinations, from, content, type, callback, logLabel, logParams) {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
-            this.log('quickSend params:', JSON.stringify(params));
+            this.log(`${logLabel} params:`, JSON.stringify(logParams));
             const sendParams = {
-                From: params.From,
-                To: toRouteDestination(params.To),
-                Content: params.Content
+                From: from,
+                To: destinations.length === 1 ? destinations[0] : destinations,
+                Content: content
             };
-            if (params.Type !== undefined) {
-                sendParams.config = { type: params.Type, dlr: 0 };
+            if (type !== undefined) {
+                sendParams.config = { type, dlr: 0 };
             }
             let result;
             try {
                 const raw = yield routemobilesms_1.routeSms.sendAsync(sendParams);
-                this.log('quickSend raw response:', JSON.stringify(raw));
+                this.log(`${logLabel} raw response:`, JSON.stringify(raw));
                 if (raw === undefined || raw === null) {
                     result = {
                         success: false,
@@ -68,15 +81,18 @@ class RouteSmsGateway {
                     };
                 }
                 else if (Array.isArray(raw) && raw.length > 0) {
+                    const allOk = raw.every(item => item.status === 'successful');
                     const first = raw[0];
-                    const ok = first.status === 'successful';
+                    const failed = raw.filter(item => item.status !== 'successful');
                     result = {
-                        success: ok,
+                        success: allOk,
                         messageId: first.id,
                         data: raw,
-                        error: ok
+                        error: allOk
                             ? undefined
-                            : `Route SMS Error [${(_a = first.code) !== null && _a !== void 0 ? _a : 'unknown'}]: ${(_b = first.message) !== null && _b !== void 0 ? _b : 'Send failed'}`
+                            : failed.length === raw.length
+                                ? `Route SMS Error [${(_a = first.code) !== null && _a !== void 0 ? _a : 'unknown'}]: ${(_b = first.message) !== null && _b !== void 0 ? _b : 'Send failed'}`
+                                : `Route SMS: ${failed.length} of ${raw.length} destinations failed`
                     };
                 }
                 else {
@@ -89,19 +105,24 @@ class RouteSmsGateway {
             }
             catch (error) {
                 const errorMessage = error instanceof Error ? error.message : String(error);
-                this.log('quickSend error:', errorMessage);
+                this.log(`${logLabel} error:`, errorMessage);
                 result = {
                     success: false,
                     error: errorMessage,
                     data: null
                 };
             }
-            this.log('quickSend result:', JSON.stringify(result));
+            this.log(`${logLabel} result:`, JSON.stringify(result));
             if (callback) {
                 callback(result);
             }
             return result;
         });
     }
+    sendPersonalized(_params, _callback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error('Route Mobile does not support sendPersonalized(). Use send() with the same content for all recipients.');
+        });
+    }
 }
 exports.RouteSmsGateway = RouteSmsGateway;

package/dist/lib/types.d.ts

@@ -17,11 +17,60 @@ export interface QuickSendParamsCamel {
     type?: number;
 }
 export declare type QuickSendParamsInput = QuickSendParams | QuickSendParamsCamel;
+export interface SendParams {
+    From: string;
+    To: (string | number)[];
+    Content: string;
+    Type?: number;
+}
+/**
+ * camelCase variant of {@link SendParams}.
+ */
+export interface SendParamsCamel {
+    from: string;
+    to: (string | number)[];
+    content: string;
+    type?: number;
+}
+export declare type SendParamsInput = SendParams | SendParamsCamel;
+export interface PersonalizedRecipient {
+    To: string | number;
+    Values: (string | number)[];
+}
+export interface PersonalizedSendParams {
+    From: string;
+    Content: string;
+    Destinations: PersonalizedRecipient[];
+    Type?: number;
+}
+/**
+ * camelCase variant of {@link PersonalizedSendParams}.
+ */
+export interface PersonalizedSendParamsCamel {
+    from: string;
+    content: string;
+    destinations: {
+        to: string | number;
+        values: (string | number)[];
+    }[];
+    type?: number;
+}
+export declare type PersonalizedSendParamsInput = PersonalizedSendParams | PersonalizedSendParamsCamel;
 /**
  * Maps PascalCase or camelCase quick-send fields to {@link QuickSendParams}.
  * PascalCase wins when both are present.
  */
 export declare function normalizeQuickSendParams(params: QuickSendParamsInput): QuickSendParams;
+/**
+ * Maps PascalCase or camelCase multi-destination send fields to {@link SendParams}.
+ * PascalCase wins when both are present.
+ */
+export declare function normalizeSendParams(params: SendParamsInput): SendParams;
+/**
+ * Maps PascalCase or camelCase personalised bulk-send fields to
+ * {@link PersonalizedSendParams}. PascalCase wins when both are present.
+ */
+export declare function normalizePersonalizedSendParams(params: PersonalizedSendParamsInput): PersonalizedSendParams;
 export interface SendResult {
     success: boolean;
     messageId?: string;
@@ -65,6 +114,13 @@ export interface IgatewayParam {
      * `retries` setting. Default: true.
      */
     keepAlive?: boolean;
+    /** nest only — SMSOnlineGH delivery push webhook */
+    deliveryCallback?: NestDeliveryCallbackConfig;
+}
+export declare type NestDeliveryCallbackAccept = 'application/json' | 'application/xml';
+export interface NestDeliveryCallbackConfig {
+    url: string;
+    accept?: NestDeliveryCallbackAccept;
 }
 export interface IgatewaySettings {
     platformId: PlatformId;
@@ -73,6 +129,8 @@ export interface IgatewaySettings {
 /** Send surface used by the facade; third-party SDKs may omit `init()`. */
 export interface ISmsGatewayDelegate {
     quickSend(params: QuickSendParams, callback?: Function): Promise<SendResult>;
+    send(params: SendParams, callback?: Function): Promise<SendResult>;
+    sendPersonalized(params: PersonalizedSendParams, callback?: Function): Promise<SendResult>;
     getBalance?(): Promise<any>;
 }
 export interface ISmsGateway extends ISmsGatewayDelegate {
@@ -91,6 +149,8 @@ export interface NestSmsConfig {
     retries?: number;
     /** Enable HTTP keep-alive connection pooling. Default: true. */
     keepAlive?: boolean;
+    /** SMSOnlineGH delivery push webhook; included in every send when set. */
+    deliveryCallback?: NestDeliveryCallbackConfig;
 }
 export interface NestSendResponse {
     handshake: {

package/dist/lib/types.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeQuickSendParams = void 0;
+exports.normalizePersonalizedSendParams = exports.normalizeSendParams = exports.normalizeQuickSendParams = void 0;
 /**
  * Maps PascalCase or camelCase quick-send fields to {@link QuickSendParams}.
  * PascalCase wins when both are present.
@@ -40,3 +40,115 @@ function normalizeQuickSendParams(params) {
     };
 }
 exports.normalizeQuickSendParams = normalizeQuickSendParams;
+/**
+ * Maps PascalCase or camelCase multi-destination send fields to {@link SendParams}.
+ * PascalCase wins when both are present.
+ */
+function normalizeSendParams(params) {
+    var _a, _b, _c, _d;
+    const p = params;
+    const from = (_a = p.From) !== null && _a !== void 0 ? _a : p.from;
+    const to = (_b = p.To) !== null && _b !== void 0 ? _b : p.to;
+    const content = (_c = p.Content) !== null && _c !== void 0 ? _c : p.content;
+    const type = (_d = p.Type) !== null && _d !== void 0 ? _d : p.type;
+    const contentStr = content == null ? '' : String(content);
+    const trimmedBody = contentStr.trim();
+    if (trimmedBody === '') {
+        throw new Error('send: message body is missing. Pass Content or content with a non-empty string.');
+    }
+    const fromStr = from == null ? '' : String(from).trim();
+    if (fromStr === '') {
+        throw new Error('send: sender is missing. Pass From or from with a non-empty string.');
+    }
+    if (!Array.isArray(to) || to.length === 0) {
+        throw new Error('send: at least one recipient is required. Pass To or to as a non-empty array.');
+    }
+    const recipients = [];
+    for (let i = 0; i < to.length; i++) {
+        const item = to[i];
+        if (item === null || item === undefined) {
+            throw new Error(`send: recipient at index ${i} is missing.`);
+        }
+        if (typeof item === 'number') {
+            recipients.push(item);
+            continue;
+        }
+        const trimmed = String(item).trim();
+        if (trimmed === '') {
+            throw new Error(`send: recipient at index ${i} is empty.`);
+        }
+        recipients.push(trimmed);
+    }
+    let typeNum;
+    if (type !== undefined && type !== null) {
+        const n = Number(type);
+        if (!Number.isNaN(n)) {
+            typeNum = n;
+        }
+    }
+    return {
+        From: fromStr,
+        To: recipients,
+        Content: trimmedBody,
+        Type: typeNum
+    };
+}
+exports.normalizeSendParams = normalizeSendParams;
+/**
+ * Maps PascalCase or camelCase personalised bulk-send fields to
+ * {@link PersonalizedSendParams}. PascalCase wins when both are present.
+ */
+function normalizePersonalizedSendParams(params) {
+    var _a, _b, _c, _d, _e, _f;
+    const p = params;
+    const from = (_a = p.From) !== null && _a !== void 0 ? _a : p.from;
+    const content = (_b = p.Content) !== null && _b !== void 0 ? _b : p.content;
+    const destinations = (_c = p.Destinations) !== null && _c !== void 0 ? _c : p.destinations;
+    const type = (_d = p.Type) !== null && _d !== void 0 ? _d : p.type;
+    const contentStr = content == null ? '' : String(content);
+    const trimmedBody = contentStr.trim();
+    if (trimmedBody === '') {
+        throw new Error('sendPersonalized: message template is missing. Pass Content or content with a non-empty string.');
+    }
+    const fromStr = from == null ? '' : String(from).trim();
+    if (fromStr === '') {
+        throw new Error('sendPersonalized: sender is missing. Pass From or from with a non-empty string.');
+    }
+    if (!Array.isArray(destinations) || destinations.length === 0) {
+        throw new Error('sendPersonalized: at least one destination is required. Pass Destinations or destinations as a non-empty array.');
+    }
+    const normalizedDestinations = [];
+    for (let i = 0; i < destinations.length; i++) {
+        const item = destinations[i];
+        const to = (_e = item.To) !== null && _e !== void 0 ? _e : item.to;
+        const values = (_f = item.Values) !== null && _f !== void 0 ? _f : item.values;
+        if (to === null || to === undefined) {
+            throw new Error(`sendPersonalized: destination at index ${i} is missing To or to.`);
+        }
+        const toVal = typeof to === 'number' ? to : String(to).trim();
+        if (typeof toVal === 'string' && toVal === '') {
+            throw new Error(`sendPersonalized: destination at index ${i} has an empty To or to.`);
+        }
+        if (!Array.isArray(values)) {
+            throw new Error(`sendPersonalized: destination at index ${i} requires Values or values as an array.`);
+        }
+        normalizedDestinations.push({
+            To: toVal,
+            Values: values
+        });
+    }
+    let typeNum;
+    if (type !== undefined && type !== null) {
+        const n = Number(type);
+        if (!Number.isNaN(n)) {
+            typeNum = n;
+        }
+    }
+    return {
+        From: fromStr,
+        Content: trimmedBody,
+        Destinations: normalizedDestinations,
+        Type: typeNum
+    };
+}
+exports.normalizePersonalizedSendParams = normalizePersonalizedSendParams;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unismsgateway",
-  "version": "1.5.3",
+  "version": "1.6.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",