@wazapi/sdk 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022-2026 Oryn Labs LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,144 @@
+# @wazapi/sdk
+
+Official Node.js SDK for the [Wazapi](https://wazapi.io) Public API v1 — a
+server-to-server client for sending WhatsApp messages, triggering flows, and
+managing contacts/templates.
+
+- Zero runtime dependencies (uses the native `fetch` on Node 18+).
+- Fully typed against the OpenAPI contract (`GET /api/openapi/v1.json`).
+- Automatic `Idempotency-Key` generation for write operations.
+- Built-in polling helper for asynchronous operations.
+
+## Install
+
+```bash
+pnpm add @wazapi/sdk
+```
+
+## Quick start
+
+```ts
+import { WazapiClient } from '@wazapi/sdk'
+
+const wazapi = new WazapiClient({ token: process.env.WAZAPI_API_TOKEN! })
+
+// Discover a WhatsApp channel
+const channels = await wazapi.listChannels()
+const channel = channels.find((c) => c.capabilities.send_template)
+if (!channel) throw new Error('No channel able to send templates')
+
+// Fire a template and wait for the result
+const { operation } = await wazapi.sendTemplate(channel.uuid, '+5511999998888', {
+  name: 'order_confirmed',
+  parameters: ['Maria', '1847'],
+})
+const final = await wazapi.waitForOperation(operation.uuid)
+console.log(final.status) // 'succeeded' | 'failed'
+```
+
+## Sending a template (recommended flow)
+
+Templates must be **APPROVED** and you must send exactly the number of body
+parameters the template declares. Discover that shape first instead of guessing:
+
+```ts
+const template = await wazapi.getTemplate('order_confirmed')
+
+// How many positional {{1}}..{{n}} the body expects:
+const expected = template.variables.body_parameter_count
+
+// Templates needing a media/variable header, named params, or dynamic buttons
+// are not sendable through the API yet — check before building the payload:
+const sendable =
+  !template.variables.header?.has_variable &&
+  template.variables.header?.format !== 'IMAGE' &&
+  !template.variables.has_dynamic_buttons
+
+const { operation, replayed } = await wazapi.sendTemplate(
+  channel.uuid,
+  '+5511999998888',
+  { name: template.name, language: template.language, parameters: ['Maria', '1847'] },
+  // Optional: pass your own idempotency key (e.g. the order id) so retries
+  // never send twice. Omit it and the SDK generates a UUID per call.
+  'order-1847-confirmation'
+)
+```
+
+The send is asynchronous: the API returns `202 Accepted` with an operation you
+poll (or receive via webhook). `waitForOperation` handles the polling:
+
+```ts
+const result = await wazapi.waitForOperation(operation.uuid, {
+  intervalMs: 1000,
+  timeoutMs: 60_000,
+})
+if (result.status === 'failed') {
+  console.error(result.error?.code, result.error?.message)
+}
+```
+
+## Error handling
+
+Every non-2xx response throws a `WazapiError` carrying the stable error envelope:
+
+```ts
+import { WazapiError } from '@wazapi/sdk'
+
+try {
+  await wazapi.sendTemplate(channel.uuid, '+5511999998888', {
+    name: 'order_confirmed',
+    parameters: ['Maria'], // wrong count
+  })
+} catch (err) {
+  if (err instanceof WazapiError) {
+    console.error(err.code) // 'template_parameter_count_mismatch'
+    console.error(err.requestId) // quote this to support
+    if (err.isRateLimited) console.error('retry after', err.retryAfter, 's')
+  }
+}
+```
+
+Common template send error codes (all rejected synchronously, before an
+operation is created):
+
+| Code                                | Meaning                                              |
+| ----------------------------------- | ---------------------------------------------------- |
+| `template_not_found`                | No APPROVED template with that name.                 |
+| `template_language_unavailable`     | No approved version in the requested `language`.     |
+| `template_parameter_count_mismatch` | `parameters.length` ≠ `body_parameter_count`.        |
+| `template_format_unsupported`       | Needs media/variable header, named params, buttons.  |
+
+## Contacts
+
+```ts
+// Upsert by your own system's id — idempotent, safe to call repeatedly
+await wazapi.upsertContactByExternalId('customer-1847', {
+  phone: '+5511999998888',
+  name: 'Maria Silva',
+  custom_fields: { tier: 'gold' },
+})
+```
+
+## Configuration
+
+```ts
+new WazapiClient({
+  token: 'waz_api_...',
+  baseUrl: 'https://wazapi.io/api/v1', // default
+  timeoutMs: 30_000, // per-request timeout
+  idempotencyKeyFactory: () => myKey(), // default: crypto.randomUUID()
+})
+```
+
+## API surface
+
+- `listChannels()`
+- `listContacts(params)`, `getContact(uuid)`, `updateContact(uuid, input)`, `upsertContactByExternalId(externalId, input)`
+- `listTemplates(params)`, `getTemplate(name)`
+- `listFlows(params)`, `getFlow(uuid)`, `executeFlow(flowUuid, input, idempotencyKey?)`
+- `listConversations(params)`, `getConversation(uuid)`, `listMessages(conversationUuid, params)`
+- `sendMessage(input, idempotencyKey?)`, `sendText(...)`, `sendTemplate(...)`
+- `getOperation(uuid)`, `waitForOperation(uuid, options?)`
+
+See the OpenAPI contract at `https://wazapi.io/api/openapi/v1.json` for the full
+schema.

package/dist/client.d.ts

@@ -0,0 +1,69 @@
+import type { AcceptedResult, Channel, Contact, ContactWrite, Conversation, ExecuteFlowInput, Flow, ListParams, Message, Operation, Paginated, SendMessageInput, Template } from './types.js';
+export interface WazapiClientOptions {
+    /** Bearer token issued in Settings → Wazapi API (starts with `waz_api_`). */
+    token: string;
+    /** API base URL. Defaults to the production endpoint. */
+    baseUrl?: string;
+    /** Custom fetch implementation (defaults to global fetch). */
+    fetch?: typeof fetch;
+    /** Per-request timeout in milliseconds. Defaults to 30000. */
+    timeoutMs?: number;
+    /**
+     * Generates the Idempotency-Key for write operations when the caller does not
+     * pass one. Defaults to `crypto.randomUUID()`.
+     */
+    idempotencyKeyFactory?: () => string;
+}
+export interface WaitForOperationOptions {
+    /** Poll interval in milliseconds. Defaults to 1000. */
+    intervalMs?: number;
+    /** Max time to wait before throwing a timeout error. Defaults to 60000. */
+    timeoutMs?: number;
+    /**
+     * Treat `waiting` as terminal too (a flow that parked on user input). Defaults
+     * to false, so `waitForOperation` only resolves on `succeeded`/`failed`.
+     */
+    resolveOnWaiting?: boolean;
+}
+export declare class WazapiClient {
+    private readonly token;
+    private readonly baseUrl;
+    private readonly fetchImpl;
+    private readonly timeoutMs;
+    private readonly newIdempotencyKey;
+    constructor(options: WazapiClientOptions);
+    listChannels(): Promise<Channel[]>;
+    listContacts(params?: ListParams): Promise<Paginated<Contact>>;
+    getContact(uuid: string): Promise<Contact>;
+    updateContact(uuid: string, input: ContactWrite): Promise<Contact>;
+    upsertContactByExternalId(externalId: string, input: ContactWrite & {
+        phone: string;
+    }): Promise<Contact>;
+    listTemplates(params?: ListParams): Promise<Paginated<Template>>;
+    getTemplate(name: string): Promise<Template>;
+    listFlows(params?: ListParams): Promise<Paginated<Flow>>;
+    getFlow(uuid: string): Promise<Flow>;
+    executeFlow(flowUuid: string, input: ExecuteFlowInput, idempotencyKey?: string): Promise<AcceptedResult>;
+    listConversations(params?: ListParams): Promise<Paginated<Conversation>>;
+    getConversation(uuid: string): Promise<Conversation>;
+    listMessages(conversationUuid: string, params?: ListParams): Promise<Paginated<Message>>;
+    sendMessage(input: SendMessageInput, idempotencyKey?: string): Promise<AcceptedResult>;
+    /** Convenience wrapper for a plain text send. */
+    sendText(channelUuid: string, phone: string, text: string, idempotencyKey?: string): Promise<AcceptedResult>;
+    /** Convenience wrapper for a template send with positional body parameters. */
+    sendTemplate(channelUuid: string, phone: string, template: {
+        name: string;
+        language?: string;
+        parameters?: string[];
+    }, idempotencyKey?: string): Promise<AcceptedResult>;
+    getOperation(uuid: string): Promise<Operation>;
+    /**
+     * Polls an operation until it reaches a terminal status. Resolves with the final
+     * operation (which may be `failed` — inspect `operation.error`) or throws on timeout.
+     */
+    waitForOperation(uuid: string, options?: WaitForOperationOptions): Promise<Operation>;
+    private accept;
+    private request;
+    private rawRequest;
+    private withQuery;
+}

package/dist/client.js

@@ -0,0 +1,196 @@
+import { WazapiError } from './error.js';
+const TERMINAL_STATUSES = ['succeeded', 'failed'];
+export class WazapiClient {
+    token;
+    baseUrl;
+    fetchImpl;
+    timeoutMs;
+    newIdempotencyKey;
+    constructor(options) {
+        if (!options.token)
+            throw new Error('WazapiClient requires a token.');
+        this.token = options.token;
+        this.baseUrl = (options.baseUrl ?? 'https://wazapi.io/api/v1').replace(/\/$/, '');
+        this.fetchImpl = options.fetch ?? globalThis.fetch;
+        if (!this.fetchImpl)
+            throw new Error('No fetch implementation available; pass options.fetch on Node < 18.');
+        this.timeoutMs = options.timeoutMs ?? 30_000;
+        this.newIdempotencyKey =
+            options.idempotencyKeyFactory ?? (() => globalThis.crypto.randomUUID());
+    }
+    // ---- Channels ---------------------------------------------------------
+    async listChannels() {
+        const body = await this.request('GET', '/channels');
+        return body.data;
+    }
+    // ---- Contacts ---------------------------------------------------------
+    listContacts(params = {}) {
+        return this.request('GET', this.withQuery('/contacts', params));
+    }
+    async getContact(uuid) {
+        const body = await this.request('GET', `/contacts/${encode(uuid)}`);
+        return body.data;
+    }
+    async updateContact(uuid, input) {
+        const body = await this.request('PATCH', `/contacts/${encode(uuid)}`, { body: input });
+        return body.data;
+    }
+    async upsertContactByExternalId(externalId, input) {
+        const body = await this.request('PUT', `/contacts/external/${encode(externalId)}`, { body: input });
+        return body.data;
+    }
+    // ---- Templates --------------------------------------------------------
+    listTemplates(params = {}) {
+        return this.request('GET', this.withQuery('/templates', params));
+    }
+    async getTemplate(name) {
+        const body = await this.request('GET', `/templates/${encode(name)}`);
+        return body.data;
+    }
+    // ---- Flows ------------------------------------------------------------
+    listFlows(params = {}) {
+        return this.request('GET', this.withQuery('/flows', params));
+    }
+    async getFlow(uuid) {
+        const body = await this.request('GET', `/flows/${encode(uuid)}`);
+        return body.data;
+    }
+    executeFlow(flowUuid, input, idempotencyKey) {
+        return this.accept('POST', `/flows/${encode(flowUuid)}/executions`, input, idempotencyKey);
+    }
+    // ---- Conversations ----------------------------------------------------
+    listConversations(params = {}) {
+        return this.request('GET', this.withQuery('/conversations', params));
+    }
+    async getConversation(uuid) {
+        const body = await this.request('GET', `/conversations/${encode(uuid)}`);
+        return body.data;
+    }
+    listMessages(conversationUuid, params = {}) {
+        return this.request('GET', this.withQuery(`/conversations/${encode(conversationUuid)}/messages`, params));
+    }
+    // ---- Messages ---------------------------------------------------------
+    sendMessage(input, idempotencyKey) {
+        return this.accept('POST', '/messages', input, idempotencyKey);
+    }
+    /** Convenience wrapper for a plain text send. */
+    sendText(channelUuid, phone, text, idempotencyKey) {
+        return this.sendMessage({ channel_uuid: channelUuid, recipient: { phone }, type: 'text', content: { text } }, idempotencyKey);
+    }
+    /** Convenience wrapper for a template send with positional body parameters. */
+    sendTemplate(channelUuid, phone, template, idempotencyKey) {
+        return this.sendMessage({ channel_uuid: channelUuid, recipient: { phone }, type: 'template', content: template }, idempotencyKey);
+    }
+    // ---- Operations -------------------------------------------------------
+    async getOperation(uuid) {
+        const body = await this.request('GET', `/operations/${encode(uuid)}`);
+        return body.data;
+    }
+    /**
+     * Polls an operation until it reaches a terminal status. Resolves with the final
+     * operation (which may be `failed` — inspect `operation.error`) or throws on timeout.
+     */
+    async waitForOperation(uuid, options = {}) {
+        const interval = options.intervalMs ?? 1000;
+        const deadline = Date.now() + (options.timeoutMs ?? 60_000);
+        const terminal = options.resolveOnWaiting
+            ? [...TERMINAL_STATUSES, 'waiting']
+            : TERMINAL_STATUSES;
+        for (;;) {
+            const operation = await this.getOperation(uuid);
+            if (terminal.includes(operation.status))
+                return operation;
+            if (Date.now() >= deadline)
+                throw new WazapiError({
+                    status: 0,
+                    code: 'operation_wait_timeout',
+                    message: `Operation ${uuid} did not reach a terminal status in time.`,
+                });
+            await delay(Math.min(interval, Math.max(0, deadline - Date.now())));
+        }
+    }
+    // ---- Internals --------------------------------------------------------
+    async accept(method, path, body, idempotencyKey) {
+        const key = idempotencyKey ?? this.newIdempotencyKey();
+        const { data, headers } = await this.rawRequest(method, path, {
+            body,
+            headers: { 'Idempotency-Key': key },
+        });
+        return { operation: data.data, replayed: headers.get('Idempotent-Replayed') === 'true' };
+    }
+    async request(method, path, init = {}) {
+        const { data } = await this.rawRequest(method, path, init);
+        return data;
+    }
+    async rawRequest(method, path, init = {}) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+        let response;
+        try {
+            response = await this.fetchImpl(`${this.baseUrl}${path}`, {
+                method,
+                signal: controller.signal,
+                headers: {
+                    Authorization: `Bearer ${this.token}`,
+                    Accept: 'application/json',
+                    ...(init.body !== undefined ? { 'Content-Type': 'application/json' } : {}),
+                    ...init.headers,
+                },
+                body: init.body !== undefined ? JSON.stringify(init.body) : undefined,
+            });
+        }
+        catch (cause) {
+            clearTimeout(timer);
+            if (cause instanceof Error && cause.name === 'AbortError')
+                throw new WazapiError({
+                    status: 0,
+                    code: 'request_timeout',
+                    message: `Request to ${path} timed out after ${this.timeoutMs}ms.`,
+                });
+            throw new WazapiError({
+                status: 0,
+                code: 'network_error',
+                message: cause instanceof Error ? cause.message : 'Network request failed.',
+            });
+        }
+        clearTimeout(timer);
+        const text = await response.text();
+        const parsed = text ? safeJson(text) : null;
+        if (!response.ok) {
+            const envelope = parsed?.error;
+            const retryAfterHeader = response.headers.get('Retry-After');
+            throw new WazapiError({
+                status: response.status,
+                code: envelope?.code ?? 'http_error',
+                message: envelope?.message ?? `Request failed with status ${response.status}.`,
+                requestId: envelope?.request_id ?? null,
+                details: envelope?.details ?? null,
+                retryAfter: retryAfterHeader ? Number(retryAfterHeader) : null,
+            });
+        }
+        return { data: parsed, headers: response.headers };
+    }
+    withQuery(path, params) {
+        const search = new URLSearchParams();
+        for (const [key, value] of Object.entries(params)) {
+            if (value !== undefined && value !== null)
+                search.set(key, String(value));
+        }
+        const qs = search.toString();
+        return qs ? `${path}?${qs}` : path;
+    }
+}
+function encode(segment) {
+    return encodeURIComponent(segment);
+}
+function safeJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/error.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Error thrown for any non-2xx response from the Wazapi API. Carries the stable
+ * error envelope (`code`, `message`, `request_id`) so callers can branch on
+ * `error.code` — e.g. `template_parameter_count_mismatch` — and quote `request_id`
+ * to support.
+ */
+export declare class WazapiError extends Error {
+    readonly status: number;
+    readonly code: string;
+    readonly requestId: string | null;
+    readonly details: unknown;
+    /** Value of the `Retry-After` header on a 429, in seconds, when present. */
+    readonly retryAfter: number | null;
+    constructor(input: {
+        status: number;
+        code: string;
+        message: string;
+        requestId?: string | null;
+        details?: unknown;
+        retryAfter?: number | null;
+    });
+    /** True for 429 rate-limit responses. */
+    get isRateLimited(): boolean;
+}

package/dist/error.js

@@ -0,0 +1,27 @@
+/**
+ * Error thrown for any non-2xx response from the Wazapi API. Carries the stable
+ * error envelope (`code`, `message`, `request_id`) so callers can branch on
+ * `error.code` — e.g. `template_parameter_count_mismatch` — and quote `request_id`
+ * to support.
+ */
+export class WazapiError extends Error {
+    status;
+    code;
+    requestId;
+    details;
+    /** Value of the `Retry-After` header on a 429, in seconds, when present. */
+    retryAfter;
+    constructor(input) {
+        super(input.message);
+        this.name = 'WazapiError';
+        this.status = input.status;
+        this.code = input.code;
+        this.requestId = input.requestId ?? null;
+        this.details = input.details ?? null;
+        this.retryAfter = input.retryAfter ?? null;
+    }
+    /** True for 429 rate-limit responses. */
+    get isRateLimited() {
+        return this.status === 429;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { WazapiClient } from './client.js';
+export type { WazapiClientOptions, WaitForOperationOptions } from './client.js';
+export { WazapiError } from './error.js';
+export type * from './types.js';

package/dist/index.js

@@ -0,0 +1,2 @@
+export { WazapiClient } from './client.js';
+export { WazapiError } from './error.js';

package/dist/types.d.ts

@@ -0,0 +1,145 @@
+export type PublicApiScope = 'channels:read' | 'contacts:read' | 'contacts:write' | 'conversations:read' | 'messages:read' | 'messages:write' | 'templates:read' | 'flows:read' | 'flows:execute' | 'operations:read';
+export interface PaginationMeta {
+    next_cursor: string | null;
+}
+export interface Paginated<T> {
+    data: T[];
+    meta: PaginationMeta;
+}
+export interface Envelope<T> {
+    data: T;
+}
+export interface ChannelCapabilities {
+    send_text: boolean;
+    send_template: boolean;
+    start_flow: boolean;
+}
+export interface Channel {
+    uuid: string;
+    provider: 'whatsapp';
+    display_name: string | null;
+    phone_number: string | null;
+    status: string;
+    capabilities: ChannelCapabilities;
+}
+export interface Contact {
+    uuid: string;
+    external_id: string | null;
+    phone: string | null;
+    name: string | null;
+    email: string | null;
+    tags: string[];
+    custom_fields: Record<string, unknown>;
+    last_interaction_at: string | null;
+    created_at: string | null;
+    updated_at: string | null;
+}
+export interface ContactWrite {
+    name?: string | null;
+    email?: string | null;
+    tags?: string[];
+    custom_fields?: Record<string, unknown>;
+}
+export interface Flow {
+    uuid: string;
+    name: string;
+    status: 'draft' | 'active';
+    supported_providers: string[];
+    created_at: string | null;
+    updated_at: string | null;
+}
+export type TemplateStatus = 'APPROVED' | 'PENDING' | 'REJECTED' | 'PAUSED' | 'DISABLED' | 'IN_APPEAL' | 'DRAFT';
+export type TemplateCategory = 'AUTHENTICATION' | 'MARKETING' | 'UTILITY';
+export interface TemplateVariables {
+    body_parameter_count: number;
+    body_named_parameters: string[];
+    header: {
+        format: string;
+        has_variable: boolean;
+    } | null;
+    has_dynamic_buttons: boolean;
+}
+export interface Template {
+    uuid: string;
+    name: string;
+    language: string;
+    status: TemplateStatus;
+    category: TemplateCategory;
+    channel_uuid: string | null;
+    variables: TemplateVariables;
+    created_at: string | null;
+    updated_at: string | null;
+}
+export interface Conversation {
+    uuid: string;
+    status: string;
+    channel_uuid: string | null;
+    contact: Contact | null;
+    unread_count: number;
+    last_message_at: string | null;
+    created_at: string | null;
+    updated_at: string | null;
+}
+export interface Message {
+    uuid: string;
+    direction: 'inbound' | 'outbound';
+    type: string;
+    status: string;
+    content: Record<string, unknown>;
+    provider_message_id: string | null;
+    created_at: string | null;
+    updated_at: string | null;
+}
+export type OperationStatus = 'queued' | 'processing' | 'waiting' | 'succeeded' | 'failed';
+export interface Operation {
+    uuid: string;
+    type: 'message.send' | 'flow.execute';
+    status: OperationStatus;
+    result: Record<string, unknown> | null;
+    error: {
+        code: string;
+        message: string | null;
+    } | null;
+    created_at: string | null;
+    started_at: string | null;
+    completed_at: string | null;
+}
+export interface Recipient {
+    phone: string;
+    external_id?: string;
+}
+export type SendMessageInput = {
+    channel_uuid: string;
+    recipient: Recipient;
+    type: 'text';
+    content: {
+        text: string;
+    };
+} | {
+    channel_uuid: string;
+    recipient: Recipient;
+    type: 'template';
+    content: {
+        name: string;
+        language?: string;
+        parameters?: string[];
+    };
+};
+export interface ExecuteFlowInput {
+    channel_uuid: string;
+    recipient: Recipient;
+    variables?: Record<string, unknown>;
+}
+export interface ListParams {
+    after?: string;
+    limit?: number;
+    query?: string;
+    status?: string;
+    channel_uuid?: string;
+    updated_after?: string;
+}
+export interface AcceptedResult {
+    operation: Operation;
+    /** True when the request replayed a previously accepted idempotent operation. */
+    replayed: boolean;
+}

package/dist/types.js

@@ -0,0 +1,3 @@
+// Types mirror the Wazapi Public API v1 OpenAPI contract
+// (openapi/public-api.v1.json). Keep in sync when the contract changes.
+export {};

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@wazapi/sdk",
+  "version": "0.1.0",
+  "description": "Official Node.js SDK for the Wazapi Public API v1",
+  "license": "MIT",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "homepage": "https://wazapi.io",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/wazap-ai/wazap-v2.git",
+    "directory": "apps/app/sdk"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": ["dist", "README.md"],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "npm run build && node --test --experimental-strip-types test/*.test.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": ["wazapi", "whatsapp", "api", "sdk", "messaging"],
+  "devDependencies": {
+    "typescript": "^5.6.0"
+  }
+}