@zindua/sdk 1.2.6 → 1.2.8

package/README.md

@@ -66,6 +66,24 @@ await zindua.send({
 });
 ```
 
+### WhatsApp anti-ban robot (required)
+
+Zindua runs an **anti-ban robot** on WhatsApp sends. Burst / simultaneous OTP traffic looks like spam and can **ban the number you linked** in the dashboard.
+
+- **Server:** after a WhatsApp send, wait **≥ 3 seconds** before the next one (same project), or you get `RATE_LIMIT_EXCEEDED` / `Wait Xs before sending another WhatsApp OTP`.
+- **SDK (default):** `autoPaceWhatsapp: true` waits on this client and prints a warning so you learn to space sends in your app (queue, debounce, resend countdown).
+- **Your app:** still use a queue or ≥3s gap for production UX — the SDK cannot pace across multiple servers or cold starts.
+
+Guide with Node / PHP / Python / C#: [WhatsApp OTP anti-ban pacing](https://zindua.run/blog/whatsapp-otp-anti-ban-pacing)
+
+```typescript
+// Default: SDK waits ≥3s between WhatsApp sends on this client
+const zindua = new Zindua({ apiKey: process.env.ZINDUA_API_KEY! });
+
+// Only if you already queue WhatsApp OTP yourself:
+new Zindua({ apiKey: process.env.ZINDUA_API_KEY!, autoPaceWhatsapp: false });
+```
+
 ### Channel and `to` must match
 
 The SDK checks **before** calling the API (same rules as [zindua.run](https://zindua.run)). A phone number cannot be sent as email, and an email cannot be sent on WhatsApp.
@@ -369,6 +387,32 @@ Do **not** embed `@zindua/sdk` or `znd_live_…` in the app. Call your backend r
 
 ---
 
+## WordPress site binding & `connect()`
+
+Each API key can be linked to **one site URL** (used by the [WordPress plugin](https://zindua.run/wordpress)). Pass `siteUrl` on the client so every request includes `X-Zindua-Site-Url`:
+
+```typescript
+const zindua = new Zindua({
+  apiKey: process.env.ZINDUA_API_KEY!,
+  siteUrl: "https://shop.example.com",
+});
+
+// First connect binds the key to this URL
+const status = await zindua.connect();
+console.log(status.project.name, status.templates);
+
+// Later: list templates with langs (fr, en, …)
+const { templates } = await zindua.getTemplates();
+```
+
+| Error code | Meaning |
+|------------|---------|
+| `SITE_ALREADY_BOUND` | Key already used on another site — create a new project or regenerate the key |
+| `SITE_MISMATCH` | `siteUrl` does not match the registered site |
+| `SITE_URL_REQUIRED` | Key is bound; update the SDK and set `siteUrl` |
+
+---
+
 ## Configuration options
 
 | Option | Default | Description |
@@ -376,10 +420,12 @@ Do **not** embed `@zindua/sdk` or `znd_live_…` in the app. Call your backend r
 | `apiKey` | — | **Required.** `znd_live_…` or `znd_test_…` from the dashboard. |
 | `baseUrl` | `https://zindua.run/api/v1` | Override only for local testing (`http://localhost:3000/api/v1`). |
 | `timeoutMs` | `30000` | Request timeout (max `120000`). |
+| `siteUrl` | — | Your app origin (`https://example.com`). Required once the key is site-bound. |
 
 ```typescript
 const zindua = new Zindua({
   apiKey: process.env.ZINDUA_API_KEY!,
+  siteUrl: process.env.APP_URL,
   baseUrl: process.env.ZINDUA_API_BASE_URL, // optional
   timeoutMs: 45_000,
 });
@@ -506,7 +552,7 @@ try {
 | `WHATSAPP_NOT_CONNECTED` | 422 | WhatsApp not linked. | Dashboard → project → **WhatsApp** → scan QR. |
 | `WHATSAPP_PAUSED` | 422 | WhatsApp session paused. | Resume in the dashboard. |
 | `WHATSAPP_QUOTA_EXCEEDED` | 429 | Monthly WhatsApp limit reached. | Upgrade or wait. |
-| `RATE_LIMIT_EXCEEDED` | 429 | Sending too fast (WhatsApp). | Wait `retryAfterSec` from `e.details`, then retry. |
+| `RATE_LIMIT_EXCEEDED` | 429 | WhatsApp anti-ban robot: sending too fast. | Wait `retryAfterSec` (details), keep ≥3s gap / queue. See [anti-ban guide](https://zindua.run/blog/whatsapp-otp-anti-ban-pacing). |
 | `TEMPLATE_NOT_FOUND` | 404 | Unknown template slug. | Create template or fix slug; check `availableTemplateSlugs` in details. |
 | `TEMPLATE_NO_CONTENT` | 404 | Template has no language version. | Add content in Dashboard → Templates. |
 | `TEMPLATE_NO_WHATSAPP_BODY` | 422 | No plain text for WhatsApp. | Add a text body for that language. |

package/dist/client.d.ts

@@ -16,6 +16,52 @@ export type ZinduaClientOptions = {
     baseUrl?: string;
     /** Request timeout (default 30s, max 120s). */
     timeoutMs?: number;
+    /**
+     * Your app or WordPress site origin (e.g. https://shop.example.com).
+     * Sent as X-Zindua-Site-Url — required once the API key is bound to a site.
+     */
+    siteUrl?: string;
+    /**
+     * Override User-Agent (default Zindua-JS/{version}).
+     * Used by @zindua/cli as Zindua-CLI/{version} for admin telemetry.
+     */
+    userAgent?: string;
+    /**
+     * When true (default), the SDK waits ≥3s between WhatsApp sends on this client
+     * and logs an anti-ban warning. Mirrors Zindua’s server anti-ban robot.
+     * Set false only if your app already queues / debounces WhatsApp OTP.
+     */
+    autoPaceWhatsapp?: boolean;
+};
+export type ZinduaProjectInfo = {
+    name: string;
+    slug: string;
+    defaultLang: string;
+    dashboardUrl: string;
+};
+export type ZinduaTemplateInfo = {
+    slug: string;
+    langs: string[];
+    defaultLang: string;
+    variables: string[];
+};
+export type ZinduaConnectResult = {
+    ok: true;
+    connected: true;
+    siteUrl: string;
+    newlyBound: boolean;
+    project: ZinduaProjectInfo;
+    templates: ZinduaTemplateInfo[];
+    plan: ZinduaSendContext["plan"];
+    channels: {
+        email: {
+            ready: boolean;
+        };
+        whatsapp: {
+            ready: boolean;
+            status?: string;
+        };
+    };
 };
 export type ZinduaSendContext = {
     project: {
@@ -58,10 +104,33 @@ export type ZinduaSendResult = {
 };
 export declare class Zindua {
     private readonly apiKey;
-    private readonly sendUrl;
+    private readonly apiBase;
     private readonly timeoutMs;
+    private readonly siteUrl?;
+    private readonly userAgent;
+    private readonly autoPaceWhatsapp;
+    private lastWhatsappSendAt;
+    private whatsappPaceChain;
     constructor(options: ZinduaClientOptions);
     /** Returns true when using a znd_test_ key (sandbox / no real delivery). */
     isTestMode(): boolean;
+    /**
+     * Bind this API key to your site (WordPress connect flow).
+     * First call wins — the same key cannot be used on another site URL.
+     */
+    connect(siteUrl?: string): Promise<ZinduaConnectResult>;
+    /** Project status, channels, and plan (GET /project). */
+    getProject(): Promise<Record<string, unknown>>;
+    /** Synced templates with langs and variables (GET /templates). */
+    getTemplates(): Promise<{
+        templates: ZinduaTemplateInfo[];
+        limits?: Record<string, unknown>;
+    }>;
+    /** Delivery status for a logId returned by send() (GET /logs/{logId}). */
+    getLog(logId: string): Promise<Record<string, unknown>>;
     send(options: ZinduaSendOptions): Promise<ZinduaSendResult>;
+    /** Serialize WhatsApp sends on this client and wait for the anti-ban gap. */
+    private paceWhatsappSend;
+    private buildHeaders;
+    private request;
 }

package/dist/client.js

@@ -3,7 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Zindua = void 0;
 const errors_1 = require("./errors");
 const validate_1 = require("./validate");
-const SDK_VERSION = "1.2.6";
+const whatsapp_anti_ban_1 = require("./whatsapp-anti-ban");
+const SDK_VERSION = "1.2.8";
 const USER_AGENT = `Zindua-JS/${SDK_VERSION}`;
 function buildPayload(options, channel) {
     const to = (0, validate_1.validateRecipient)(options.to, channel);
@@ -38,7 +39,7 @@ function buildPayload(options, channel) {
     return payload;
 }
 function parseApiError(status, body) {
-    const message = typeof body.error === "string"
+    let message = typeof body.error === "string"
         ? body.error
         : typeof body.message === "string"
             ? body.message
@@ -50,16 +51,25 @@ function parseApiError(status, body) {
         details.hint = body.hint;
     if (typeof body.retryAfterSec === "number")
         details.retryAfterSec = body.retryAfterSec;
+    if (typeof body.boundSite === "string")
+        details.boundSite = body.boundSite;
     if (Array.isArray(body.availableTemplateSlugs)) {
         details.availableTemplateSlugs = body.availableTemplateSlugs;
     }
     if (body.context && typeof body.context === "object") {
         details.context = body.context;
     }
-    const fullMessage = typeof body.hint === "string" && body.hint.length > 0 ? `${message} ${body.hint}` : message;
+    const code = typeof body.code === "string" ? body.code : "API_ERROR";
+    if (code === "RATE_LIMIT_EXCEEDED" || status === 429) {
+        message = (0, whatsapp_anti_ban_1.antiBanRateLimitMessage)(message, typeof body.retryAfterSec === "number" ? body.retryAfterSec : undefined);
+        details.antiBanGuide = whatsapp_anti_ban_1.WHATSAPP_ANTI_BAN_GUIDE_URL;
+    }
+    const fullMessage = typeof body.hint === "string" && body.hint.length > 0 && code !== "RATE_LIMIT_EXCEEDED"
+        ? `${message} ${body.hint}`
+        : message;
     return new errors_1.ZinduaError(fullMessage, {
         status,
-        code: typeof body.code === "string" ? body.code : "API_ERROR",
+        code,
         details: Object.keys(details).length > 0
             ? details
             : typeof body.hint === "string"
@@ -69,34 +79,152 @@ function parseApiError(status, body) {
 }
 class Zindua {
     apiKey;
-    sendUrl;
+    apiBase;
     timeoutMs;
+    siteUrl;
+    userAgent;
+    autoPaceWhatsapp;
+    lastWhatsappSendAt = 0;
+    whatsappPaceChain = Promise.resolve();
     constructor(options) {
         (0, validate_1.assertServerRuntime)();
         this.apiKey = (0, validate_1.validateApiKey)(options.apiKey);
-        const base = (0, validate_1.resolveBaseUrl)(options.baseUrl);
-        this.sendUrl = `${base}/send`;
+        this.apiBase = (0, validate_1.resolveBaseUrl)(options.baseUrl);
         this.timeoutMs = (0, validate_1.validateTimeoutMs)(options.timeoutMs);
+        this.siteUrl = (0, validate_1.validateSiteUrl)(options.siteUrl);
+        this.userAgent =
+            typeof options.userAgent === "string" && options.userAgent.trim()
+                ? options.userAgent.trim()
+                : USER_AGENT;
+        this.autoPaceWhatsapp = options.autoPaceWhatsapp !== false;
     }
     /** Returns true when using a znd_test_ key (sandbox / no real delivery). */
     isTestMode() {
         return this.apiKey.startsWith("znd_test_");
     }
+    /**
+     * Bind this API key to your site (WordPress connect flow).
+     * First call wins — the same key cannot be used on another site URL.
+     */
+    async connect(siteUrl) {
+        const url = (0, validate_1.validateSiteUrl)(siteUrl) ?? this.siteUrl;
+        const data = await this.request("POST", "connect", {
+            siteUrl: url,
+        });
+        if (data.ok !== true || !data.project || !Array.isArray(data.templates)) {
+            throw new errors_1.ZinduaError("API response missing connect payload.", {
+                status: 200,
+                code: "INVALID_RESPONSE",
+            });
+        }
+        return {
+            ok: true,
+            connected: true,
+            siteUrl: typeof data.siteUrl === "string" ? data.siteUrl : url ?? "",
+            newlyBound: Boolean(data.newlyBound),
+            project: data.project,
+            templates: data.templates,
+            plan: data.plan ?? null,
+            channels: data.channels ?? {
+                email: { ready: false },
+                whatsapp: { ready: false },
+            },
+        };
+    }
+    /** Project status, channels, and plan (GET /project). */
+    async getProject() {
+        return this.request("GET", "project");
+    }
+    /** Synced templates with langs and variables (GET /templates). */
+    async getTemplates() {
+        const data = await this.request("GET", "templates");
+        return {
+            templates: Array.isArray(data.templates) ? data.templates : [],
+            limits: data.limits,
+        };
+    }
+    /** Delivery status for a logId returned by send() (GET /logs/{logId}). */
+    async getLog(logId) {
+        const trimmed = logId.trim();
+        if (!trimmed) {
+            throw new errors_1.ZinduaError("logId is required.", { status: 0, code: "MISSING_FIELDS" });
+        }
+        const data = await this.request("GET", `logs/${encodeURIComponent(trimmed)}`);
+        if (data.ok !== true || !data.log || typeof data.log !== "object") {
+            throw new errors_1.ZinduaError("API response missing log payload.", {
+                status: 200,
+                code: "INVALID_RESPONSE",
+            });
+        }
+        return data.log;
+    }
     async send(options) {
         const channel = (0, validate_1.validateChannel)(options.channel);
+        if (channel === "whatsapp" && this.autoPaceWhatsapp) {
+            await this.paceWhatsappSend();
+        }
         const payload = buildPayload(options, channel);
+        const data = await this.request("POST", "send", payload);
+        if (data.success !== true || typeof data.logId !== "string") {
+            throw new errors_1.ZinduaError("API response missing success or logId.", {
+                status: 200,
+                code: "INVALID_RESPONSE",
+            });
+        }
+        if (channel === "whatsapp") {
+            this.lastWhatsappSendAt = Date.now();
+        }
+        return {
+            success: true,
+            channel: (data.channel === "whatsapp" ? "whatsapp" : "email"),
+            status: typeof data.status === "string" ? data.status : "queued",
+            logId: data.logId,
+            langUsed: typeof data.langUsed === "string" ? data.langUsed : undefined,
+            langFallback: typeof data.langFallback === "boolean" ? data.langFallback : undefined,
+            testMode: typeof data.testMode === "boolean" ? data.testMode : undefined,
+            project: typeof data.project === "string" ? data.project : undefined,
+            context: data.context && typeof data.context === "object"
+                ? data.context
+                : undefined,
+        };
+    }
+    /** Serialize WhatsApp sends on this client and wait for the anti-ban gap. */
+    paceWhatsappSend() {
+        const run = async () => {
+            const elapsed = Date.now() - this.lastWhatsappSendAt;
+            if (this.lastWhatsappSendAt > 0 && elapsed < whatsapp_anti_ban_1.WHATSAPP_MIN_INTERVAL_MS) {
+                const waitMs = whatsapp_anti_ban_1.WHATSAPP_MIN_INTERVAL_MS - elapsed;
+                (0, whatsapp_anti_ban_1.warnWhatsappAntiBanPace)(waitMs);
+                await (0, whatsapp_anti_ban_1.sleepMs)(waitMs);
+            }
+        };
+        this.whatsappPaceChain = this.whatsappPaceChain.then(run, run);
+        return this.whatsappPaceChain;
+    }
+    buildHeaders() {
+        const headers = {
+            Authorization: `Bearer ${this.apiKey}`,
+            "User-Agent": this.userAgent,
+            Accept: "application/json",
+        };
+        if (this.siteUrl) {
+            headers["X-Zindua-Site-Url"] = this.siteUrl;
+        }
+        return headers;
+    }
+    async request(method, path, body) {
+        const url = `${this.apiBase}/${path.replace(/^\//, "")}`;
         const controller = new AbortController();
         const timer = setTimeout(() => controller.abort(), this.timeoutMs);
         try {
-            const response = await fetch(this.sendUrl, {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                    Authorization: `Bearer ${this.apiKey}`,
-                    "User-Agent": USER_AGENT,
-                    Accept: "application/json",
-                },
-                body: JSON.stringify(payload),
+            const headers = this.buildHeaders();
+            if (body) {
+                headers["Content-Type"] = "application/json";
+            }
+            const response = await fetch(url, {
+                method,
+                headers,
+                body: body ? JSON.stringify(body) : undefined,
                 signal: controller.signal,
                 redirect: "error",
             });
@@ -114,25 +242,7 @@ class Zindua {
             if (!response.ok) {
                 throw parseApiError(response.status, data);
             }
-            if (data.success !== true || typeof data.logId !== "string") {
-                throw new errors_1.ZinduaError("API response missing success or logId.", {
-                    status: response.status,
-                    code: "INVALID_RESPONSE",
-                });
-            }
-            return {
-                success: true,
-                channel: (data.channel === "whatsapp" ? "whatsapp" : "email"),
-                status: typeof data.status === "string" ? data.status : "queued",
-                logId: data.logId,
-                langUsed: typeof data.langUsed === "string" ? data.langUsed : undefined,
-                langFallback: typeof data.langFallback === "boolean" ? data.langFallback : undefined,
-                testMode: typeof data.testMode === "boolean" ? data.testMode : undefined,
-                project: typeof data.project === "string" ? data.project : undefined,
-                context: data.context && typeof data.context === "object"
-                    ? data.context
-                    : undefined,
-            };
+            return data;
         }
         catch (err) {
             if (err instanceof errors_1.ZinduaError)

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export { Zindua } from "./client";
-export type { ZinduaClientOptions, ZinduaSendContext, ZinduaSendOptions, ZinduaSendResult, SendChannel, } from "./client";
+export type { ZinduaClientOptions, ZinduaConnectResult, ZinduaProjectInfo, ZinduaSendContext, ZinduaSendOptions, ZinduaSendResult, ZinduaTemplateInfo, SendChannel, } from "./client";
 export { ZinduaError } from "./errors";
 export type { ZinduaErrorCode } from "./errors";
 export { DEFAULT_API_BASE, LIMITS } from "./validate";
+export { WHATSAPP_ANTI_BAN_GUIDE_URL, WHATSAPP_MIN_INTERVAL_MS, } from "./whatsapp-anti-ban";

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LIMITS = exports.DEFAULT_API_BASE = exports.ZinduaError = exports.Zindua = void 0;
+exports.WHATSAPP_MIN_INTERVAL_MS = exports.WHATSAPP_ANTI_BAN_GUIDE_URL = exports.LIMITS = exports.DEFAULT_API_BASE = exports.ZinduaError = exports.Zindua = void 0;
 var client_1 = require("./client");
 Object.defineProperty(exports, "Zindua", { enumerable: true, get: function () { return client_1.Zindua; } });
 var errors_1 = require("./errors");
@@ -8,3 +8,6 @@ Object.defineProperty(exports, "ZinduaError", { enumerable: true, get: function
 var validate_1 = require("./validate");
 Object.defineProperty(exports, "DEFAULT_API_BASE", { enumerable: true, get: function () { return validate_1.DEFAULT_API_BASE; } });
 Object.defineProperty(exports, "LIMITS", { enumerable: true, get: function () { return validate_1.LIMITS; } });
+var whatsapp_anti_ban_1 = require("./whatsapp-anti-ban");
+Object.defineProperty(exports, "WHATSAPP_ANTI_BAN_GUIDE_URL", { enumerable: true, get: function () { return whatsapp_anti_ban_1.WHATSAPP_ANTI_BAN_GUIDE_URL; } });
+Object.defineProperty(exports, "WHATSAPP_MIN_INTERVAL_MS", { enumerable: true, get: function () { return whatsapp_anti_ban_1.WHATSAPP_MIN_INTERVAL_MS; } });

package/dist/validate.d.ts

@@ -23,3 +23,5 @@ export declare function sanitizeVariables(variables?: Record<string, string>): R
 export declare function validateOptionalEmailField(field: "cc" | "bcc" | "replyTo", value?: string): string | undefined;
 export declare function validateAttachments(attachments?: unknown[]): unknown[] | undefined;
 export declare function validateTimeoutMs(timeoutMs?: number): number;
+/** Normalize site URL for WordPress one-key-one-site binding (protocol + host). */
+export declare function validateSiteUrl(siteUrl?: string): string | undefined;

package/dist/validate.js

@@ -13,6 +13,7 @@ exports.sanitizeVariables = sanitizeVariables;
 exports.validateOptionalEmailField = validateOptionalEmailField;
 exports.validateAttachments = validateAttachments;
 exports.validateTimeoutMs = validateTimeoutMs;
+exports.validateSiteUrl = validateSiteUrl;
 const errors_1 = require("./errors");
 /** Matches platform `isValidE164Phone` in zindua.run API. */
 const E164_RE = /^\+[1-9]\d{6,14}$/;
@@ -214,3 +215,21 @@ function validateTimeoutMs(timeoutMs) {
     }
     return Math.floor(timeoutMs);
 }
+/** Normalize site URL for WordPress one-key-one-site binding (protocol + host). */
+function validateSiteUrl(siteUrl) {
+    if (siteUrl === undefined || siteUrl === null)
+        return undefined;
+    const trimmed = String(siteUrl).trim();
+    if (!trimmed)
+        return undefined;
+    try {
+        const url = new URL(trimmed.includes("://") ? trimmed : `https://${trimmed}`);
+        return `${url.protocol}//${url.host}`;
+    }
+    catch {
+        throw new errors_1.ZinduaError("siteUrl must be a valid URL (e.g. https://example.com).", {
+            status: 0,
+            code: "INVALID_OPTIONS",
+        });
+    }
+}

package/dist/whatsapp-anti-ban.d.ts

@@ -0,0 +1,7 @@
+/** Zindua WhatsApp anti-ban robot — client-side pacing helpers. */
+export declare const WHATSAPP_MIN_INTERVAL_MS = 3000;
+/** Guide for developers integrating WhatsApp OTP safely. */
+export declare const WHATSAPP_ANTI_BAN_GUIDE_URL = "https://zindua.run/blog/whatsapp-otp-anti-ban-pacing";
+export declare function antiBanRateLimitMessage(baseMessage: string, retryAfterSec?: number): string;
+export declare function warnWhatsappAntiBanPace(waitMs: number): void;
+export declare function sleepMs(ms: number): Promise<void>;

package/dist/whatsapp-anti-ban.js

@@ -0,0 +1,28 @@
+"use strict";
+/** Zindua WhatsApp anti-ban robot — client-side pacing helpers. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WHATSAPP_ANTI_BAN_GUIDE_URL = exports.WHATSAPP_MIN_INTERVAL_MS = void 0;
+exports.antiBanRateLimitMessage = antiBanRateLimitMessage;
+exports.warnWhatsappAntiBanPace = warnWhatsappAntiBanPace;
+exports.sleepMs = sleepMs;
+exports.WHATSAPP_MIN_INTERVAL_MS = 3000;
+/** Guide for developers integrating WhatsApp OTP safely. */
+exports.WHATSAPP_ANTI_BAN_GUIDE_URL = "https://zindua.run/blog/whatsapp-otp-anti-ban-pacing";
+function antiBanRateLimitMessage(baseMessage, retryAfterSec) {
+    const wait = typeof retryAfterSec === "number" && retryAfterSec > 0
+        ? ` Wait ${retryAfterSec}s, then retry.`
+        : " Wait at least 3s between WhatsApp sends.";
+    return (`${baseMessage}${wait} ` +
+        `Zindua's anti-ban robot paces WhatsApp to protect your linked number from bans. ` +
+        `Space sends in your app (queue / debounce) or keep SDK autoPaceWhatsapp on. ` +
+        `Guide: ${exports.WHATSAPP_ANTI_BAN_GUIDE_URL}`);
+}
+function warnWhatsappAntiBanPace(waitMs) {
+    const sec = Math.ceil(waitMs / 1000);
+    console.warn(`[Zindua anti-ban] Waiting ${sec}s before WhatsApp send — ` +
+        `rapid OTP looks like spam and can ban your linked number. ` +
+        `Prefer a queue or ≥3s gap in your code. ${exports.WHATSAPP_ANTI_BAN_GUIDE_URL}`);
+}
+async function sleepMs(ms) {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zindua/sdk",
-  "version": "1.2.6",
+  "version": "1.2.8",
   "description": "Official Zindua SDK for Node.js — transactional email and WhatsApp via POST /api/v1/send.",
   "author": "Zindua",
   "license": "MIT",