@fastermessage/sdk 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Urban Technology
+
+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

@@ -1,3 +1,127 @@
-# Temporary Holding Version
+# FasterMessage Node.js
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+SDK Node.js officiel de l'API FasterMessage v2 : SMS, e-mail, codes de vérification (OTP), contacts et webhooks.
+
+Node.js 20.3 ou plus récent. Aucune dépendance. Types TypeScript inclus, en ESM comme en CommonJS.
+
+```bash
+npm install @fastermessage/sdk
+```
+
+> Côté serveur seulement : le client porte vos identifiants et refuse de démarrer dans un navigateur.
+
+## Démarrage
+
+```js
+import { FasterMessage } from '@fastermessage/sdk';
+// CommonJS : const { FasterMessage } = require('@fastermessage/sdk');
+
+const fm = new FasterMessage({
+  username: process.env.FM_API_USER,
+  password: process.env.FM_API_PASSWORD,
+  apiKey: process.env.FM_API_KEY, // fm_test_… simule, fm_live_… envoie et débite
+});
+
+const message = await fm.sms.send({
+  to: '+2290160000000',
+  from: 'FASTERMSG',
+  content: 'Votre commande est prete.',
+  client_reference: 'cmd-42',
+});
+
+console.log(message.id, message.status); // queued
+```
+
+Sur le domaine d'API de votre marque : `new FasterMessage({ ..., baseUrl: 'https://api.votre-marque.com' })`.
+
+## Ce que fait le SDK
+
+| Besoin | Appel |
+|---|---|
+| SMS | `fm.sms.send()`, `fm.sms.sendBatch()` (500 lignes) |
+| E-mail | `fm.email.send()` |
+| Canal en paramètre | `fm.messages.send()` |
+| Suivi | `fm.messages.get()`, `list()`, `all()` |
+| OTP | `fm.otp.request()`, `fm.otp.verify()` |
+| Contacts | `fm.contacts`, `fm.contactGroups` : `create`, `get`, `list`, `all`, `update`, `delete` |
+| Compte | `fm.account.balance()`, `credits()`, `allCredits()` |
+| Webhooks | `Webhook.isGenuine()` |
+
+Les paramètres et les réponses gardent les noms de champs de l'API (`client_reference`, `created_at`) : un champ ajouté par l'API est disponible sans mise à jour du SDK. La référence complète est dans la [documentation de l'API](https://www.fastermessage.com/docs).
+
+`all()` parcourt toutes les pages et ne demande la suivante que si vous continuez :
+
+```js
+for await (const contact of fm.contacts.all({ group_id: 'g_123' })) {
+  console.log(contact.phone_number);
+}
+```
+
+WhatsApp et la voix ne sont pas encore servis par l'API v2.
+
+## Rejeux sans double envoi
+
+Chaque écriture porte une clé `Idempotency-Key` générée. Le SDK rejoue seul, avec la même clé et deux fois au plus, une coupure réseau, un `5xx` (sauf `501`) et un `429` qui annonce `Retry-After`.
+
+Passez votre propre clé pour survivre à un redémarrage de votre programme :
+
+```js
+await fm.sms.send(params, { idempotencyKey: 'commande-42-confirmation' });
+```
+
+## Erreurs
+
+```js
+import { ApiError, ConnectionError, InsufficientBalanceError } from '@fastermessage/sdk';
+
+try {
+  await fm.sms.send(params);
+} catch (error) {
+  if (error instanceof InsufficientBalanceError) {
+    // Rechargez le compte débité.
+  } else if (error instanceof ApiError) {
+    // Testez code, stable, et non le message.
+    console.error(error.status, error.code, error.param, error.requestId);
+  } else if (error instanceof ConnectionError) {
+    // L'appel a pu aboutir : rejouez avec error.idempotencyKey, jamais avec une nouvelle clé.
+  } else {
+    throw error;
+  }
+}
+```
+
+Erreurs : `InvalidRequestError` (400), `AuthenticationError` (401), `InsufficientBalanceError` (402), `PermissionError` (403), `NotFoundError` (404), `ConflictError` (409), `RateLimitError` (429), `NotImplementedError` (501), `ServerError` (5xx).
+
+Dans un lot, lisez toujours `errors` : un retour normal ne garantit pas que toutes les lignes soient parties.
+
+## Webhooks
+
+Vérifiez la signature sur le corps **brut**, avant tout décodage JSON. Avec Express :
+
+```js
+import express from 'express';
+import { Webhook } from '@fastermessage/sdk';
+
+const app = express();
+
+app.post('/webhooks/fastermessage', express.raw({ type: 'application/json' }), (req, res) => {
+  const genuine = Webhook.isGenuine(req.body, req.get('X-Fastermessage-Signature'), process.env.FM_WEBHOOK_SECRET);
+  if (!genuine) return res.sendStatus(401);
+
+  res.sendStatus(200); // Répondez sous 10 secondes, traitez ensuite.
+  const event = JSON.parse(req.body);
+});
+```
+
+Générez le secret dans « Intégration & API ». Le rappel SMS a le format `uuid`, `level`, `status` ; le rappel e-mail `id`, `status`, `error`.
+
+## Tests
+
+```bash
+npm install
+npm test
+```
+
+## Licence
+
+MIT.

package/dist/cjs/client.d.ts

@@ -0,0 +1,34 @@
+import { Account, ContactGroups, Contacts, Email, Messages, OtpResource, Sms } from './resources.js';
+export declare const DEFAULT_BASE_URL = "https://api.fastermessage.com";
+export interface FasterMessageOptions {
+    /** Identifiant d'API, compte débité. */
+    username: string;
+    /** Mot de passe d'API. */
+    password: string;
+    /** Clé `fm_live_…` (réel) ou `fm_test_…` (simulé). */
+    apiKey: string;
+    /** Le domaine d'API de votre marque, le cas échéant. */
+    baseUrl?: string;
+    /** Délai de chaque tentative, en millisecondes. 30 000 par défaut. */
+    timeout?: number;
+    /** Nombre de reprises après la première tentative. 2 par défaut. */
+    maxRetries?: number;
+    /** Remplace `fetch`, par exemple pour passer par un proxy ou pour vos tests. */
+    fetch?: typeof globalThis.fetch;
+    /** Remplace l'attente entre deux reprises, surtout utile dans vos tests. */
+    sleep?: (milliseconds: number) => Promise<void>;
+}
+/** Point d'entrée du SDK. Côté serveur seulement : il porte vos identifiants. */
+export declare class FasterMessage {
+    #private;
+    readonly sms: Sms;
+    readonly email: Email;
+    readonly messages: Messages;
+    readonly otp: OtpResource;
+    readonly contacts: Contacts;
+    readonly contactGroups: ContactGroups;
+    readonly account: Account;
+    constructor(options: FasterMessageOptions);
+    /** Vrai avec une clé de test : messages et OTP simulés, mais contacts et soldes réels. */
+    get testMode(): boolean;
+}

package/dist/cjs/client.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FasterMessage = exports.DEFAULT_BASE_URL = void 0;
+const http_js_1 = require("./http.js");
+const resources_js_1 = require("./resources.js");
+exports.DEFAULT_BASE_URL = 'https://api.fastermessage.com';
+/** Point d'entrée du SDK. Côté serveur seulement : il porte vos identifiants. */
+class FasterMessage {
+    sms;
+    email;
+    messages;
+    otp;
+    contacts;
+    contactGroups;
+    account;
+    #testMode;
+    constructor(options) {
+        const { username, password, apiKey } = options ?? {};
+        if (!username || !password || !apiKey) {
+            throw new TypeError("L'identifiant, le mot de passe et la clé d'API sont tous obligatoires.");
+        }
+        if ('window' in globalThis && 'document' in globalThis) {
+            throw new Error('Le SDK FasterMessage ne s’utilise pas dans un navigateur : vos identifiants y seraient publics.');
+        }
+        this.#testMode = apiKey.includes('_test_');
+        const http = new http_js_1.Requester({
+            authorization: `Basic ${Buffer.from(`${username}:${password}`).toString('base64')}`,
+            apiKey,
+            baseUrl: (options.baseUrl ?? exports.DEFAULT_BASE_URL).replace(/\/+$/, ''),
+            timeout: options.timeout ?? 30_000,
+            maxRetries: Math.max(0, options.maxRetries ?? 2),
+            ...(options.fetch ? { fetch: options.fetch } : {}),
+            ...(options.sleep ? { sleep: options.sleep } : {}),
+        });
+        this.sms = new resources_js_1.Sms(http);
+        this.email = new resources_js_1.Email(http);
+        this.messages = new resources_js_1.Messages(http);
+        this.otp = new resources_js_1.OtpResource(http);
+        this.contacts = new resources_js_1.Contacts(http);
+        this.contactGroups = new resources_js_1.ContactGroups(http);
+        this.account = new resources_js_1.Account(http);
+    }
+    /** Vrai avec une clé de test : messages et OTP simulés, mais contacts et soldes réels. */
+    get testMode() {
+        return this.#testMode;
+    }
+    /** Évite d'écrire le moindre détail du client dans un journal par `console.log`. */
+    [Symbol.for('nodejs.util.inspect.custom')]() {
+        return `FasterMessage { testMode: ${this.#testMode} }`;
+    }
+}
+exports.FasterMessage = FasterMessage;

package/dist/cjs/errors.d.ts

@@ -0,0 +1,59 @@
+/** Toute erreur levée par le SDK. */
+export declare class FasterMessageError extends Error {
+    constructor(message: string, options?: ErrorOptions);
+}
+export interface ApiErrorDetails {
+    status: number;
+    code: string;
+    type?: string;
+    param?: string | null;
+    requestId?: string | null;
+    retryAfter?: number | null;
+}
+/**
+ * Refus de l'API. Testez `code`, qui est stable : `message` est un libellé en
+ * anglais, susceptible d'être reformulé.
+ */
+export declare class ApiError extends FasterMessageError {
+    readonly status: number;
+    readonly code: string;
+    readonly type: string;
+    readonly param: string | null;
+    readonly requestId: string | null;
+    readonly retryAfter: number | null;
+    constructor(message: string, details: ApiErrorDetails);
+}
+/** 400 : la requête est à corriger. */
+export declare class InvalidRequestError extends ApiError {
+}
+/** 401 : identifiant, mot de passe ou clé refusés. */
+export declare class AuthenticationError extends ApiError {
+}
+/** 402 : solde insuffisant, le compte débité est à recharger. */
+export declare class InsufficientBalanceError extends ApiError {
+}
+/** 403 : opération interdite à ce compte. */
+export declare class PermissionError extends ApiError {
+}
+/** 404 : ressource introuvable. */
+export declare class NotFoundError extends ApiError {
+}
+/** 409 : conflit, par exemple un groupe non vide ou une clé d'idempotence réutilisée. */
+export declare class ConflictError extends ApiError {
+}
+/** 429 : débit dépassé, voir `retryAfter`. */
+export declare class RateLimitError extends ApiError {
+}
+/** 501 : fonction déclarée au contrat mais pas encore servie. */
+export declare class NotImplementedError extends ApiError {
+}
+/** 5xx : panne côté API. */
+export declare class ServerError extends ApiError {
+}
+/**
+ * Coupure réseau ou délai dépassé. L'appel a pu aboutir : rejouez avec
+ * `idempotencyKey`, jamais avec une nouvelle clé.
+ */
+export declare class ConnectionError extends FasterMessageError {
+    idempotencyKey: string | null;
+}

package/dist/cjs/errors.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionError = exports.ServerError = exports.NotImplementedError = exports.RateLimitError = exports.ConflictError = exports.NotFoundError = exports.PermissionError = exports.InsufficientBalanceError = exports.AuthenticationError = exports.InvalidRequestError = exports.ApiError = exports.FasterMessageError = void 0;
+/** Toute erreur levée par le SDK. */
+class FasterMessageError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = new.target.name;
+    }
+}
+exports.FasterMessageError = FasterMessageError;
+/**
+ * Refus de l'API. Testez `code`, qui est stable : `message` est un libellé en
+ * anglais, susceptible d'être reformulé.
+ */
+class ApiError extends FasterMessageError {
+    status;
+    code;
+    type;
+    param;
+    requestId;
+    retryAfter;
+    constructor(message, details) {
+        super(message);
+        this.status = details.status;
+        this.code = details.code;
+        this.type = details.type ?? '';
+        this.param = details.param ?? null;
+        this.requestId = details.requestId ?? null;
+        this.retryAfter = details.retryAfter ?? null;
+    }
+}
+exports.ApiError = ApiError;
+/** 400 : la requête est à corriger. */
+class InvalidRequestError extends ApiError {
+}
+exports.InvalidRequestError = InvalidRequestError;
+/** 401 : identifiant, mot de passe ou clé refusés. */
+class AuthenticationError extends ApiError {
+}
+exports.AuthenticationError = AuthenticationError;
+/** 402 : solde insuffisant, le compte débité est à recharger. */
+class InsufficientBalanceError extends ApiError {
+}
+exports.InsufficientBalanceError = InsufficientBalanceError;
+/** 403 : opération interdite à ce compte. */
+class PermissionError extends ApiError {
+}
+exports.PermissionError = PermissionError;
+/** 404 : ressource introuvable. */
+class NotFoundError extends ApiError {
+}
+exports.NotFoundError = NotFoundError;
+/** 409 : conflit, par exemple un groupe non vide ou une clé d'idempotence réutilisée. */
+class ConflictError extends ApiError {
+}
+exports.ConflictError = ConflictError;
+/** 429 : débit dépassé, voir `retryAfter`. */
+class RateLimitError extends ApiError {
+}
+exports.RateLimitError = RateLimitError;
+/** 501 : fonction déclarée au contrat mais pas encore servie. */
+class NotImplementedError extends ApiError {
+}
+exports.NotImplementedError = NotImplementedError;
+/** 5xx : panne côté API. */
+class ServerError extends ApiError {
+}
+exports.ServerError = ServerError;
+/**
+ * Coupure réseau ou délai dépassé. L'appel a pu aboutir : rejouez avec
+ * `idempotencyKey`, jamais avec une nouvelle clé.
+ */
+class ConnectionError extends FasterMessageError {
+    idempotencyKey = null;
+}
+exports.ConnectionError = ConnectionError;

package/dist/cjs/http.d.ts

@@ -0,0 +1,30 @@
+export declare const VERSION = "0.1.0";
+export interface RequestOptions {
+    /** Votre clé, pour survivre à un redémarrage de votre programme. */
+    idempotencyKey?: string;
+    /** Repris par `X-Request-Id`, pour relier l'appel à vos journaux. */
+    requestId?: string;
+    /** Annule l'appel. Une annulation n'est jamais rejouée. */
+    signal?: AbortSignal;
+}
+export interface RequesterConfig {
+    authorization: string;
+    apiKey: string;
+    baseUrl: string;
+    timeout: number;
+    maxRetries: number;
+    fetch?: typeof globalThis.fetch;
+    sleep?: (milliseconds: number) => Promise<void>;
+}
+interface Call {
+    query?: object;
+    body?: object;
+    options?: RequestOptions | undefined;
+}
+/** Le chemin unique de tous les appels : en-têtes, idempotence, reprises, erreurs. */
+export declare class Requester {
+    #private;
+    constructor(config: RequesterConfig);
+    request<T>(method: string, path: string, { query, body, options }?: Call): Promise<T>;
+}
+export {};

package/dist/cjs/http.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Requester = exports.VERSION = void 0;
+const node_crypto_1 = require("node:crypto");
+const errors_js_1 = require("./errors.js");
+exports.VERSION = '0.1.0';
+/** Un même appel rejoué garde sa clé : c'est ce qui rend une reprise sans risque. */
+const MUTATING = new Set(['POST', 'PATCH', 'PUT', 'DELETE']);
+/** Le chemin unique de tous les appels : en-têtes, idempotence, reprises, erreurs. */
+class Requester {
+    #config;
+    constructor(config) {
+        this.#config = config;
+    }
+    async request(method, path, { query, body, options = {} } = {}) {
+        const url = this.#config.baseUrl + path + queryString(query);
+        const headers = {
+            Authorization: this.#config.authorization,
+            'X-Api-Key': this.#config.apiKey,
+            Accept: 'application/json',
+            'User-Agent': `fastermessage-node/${exports.VERSION}`,
+        };
+        if (body !== undefined)
+            headers['Content-Type'] = 'application/json';
+        if (options.requestId !== undefined)
+            headers['X-Request-Id'] = options.requestId;
+        let idempotencyKey = null;
+        if (MUTATING.has(method)) {
+            idempotencyKey = options.idempotencyKey ?? `sdk-${(0, node_crypto_1.randomBytes)(16).toString('hex')}`;
+            headers['Idempotency-Key'] = idempotencyKey;
+        }
+        const payload = body === undefined ? undefined : JSON.stringify(body);
+        const sleep = this.#config.sleep ?? defaultSleep;
+        for (let attempt = 0;; attempt++) {
+            let response;
+            let text;
+            try {
+                const timeout = AbortSignal.timeout(this.#config.timeout);
+                const fetchFn = this.#config.fetch ?? globalThis.fetch;
+                response = await fetchFn(url, {
+                    method,
+                    headers,
+                    ...(payload === undefined ? {} : { body: payload }),
+                    signal: options.signal ? AbortSignal.any([options.signal, timeout]) : timeout,
+                });
+                text = await response.text();
+            }
+            catch (cause) {
+                if (options.signal?.aborted)
+                    throw options.signal.reason;
+                if (attempt >= this.#config.maxRetries) {
+                    const error = new errors_js_1.ConnectionError(`Connexion à l'API impossible : ${describe(cause)}`, { cause });
+                    error.idempotencyKey = idempotencyKey;
+                    throw error;
+                }
+                await sleep(backoff(attempt));
+                continue;
+            }
+            if (response.status < 400)
+                return decode(response, text);
+            const failure = toError(response, text);
+            const wait = retryDelay(failure, attempt);
+            if (wait === null || attempt >= this.#config.maxRetries)
+                throw failure;
+            await sleep(wait);
+        }
+    }
+}
+exports.Requester = Requester;
+function queryString(query) {
+    if (!query)
+        return '';
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(query)) {
+        if (value !== undefined && value !== null)
+            params.append(key, String(value));
+    }
+    const encoded = params.toString();
+    return encoded ? `?${encoded}` : '';
+}
+/**
+ * Reprise seulement si la même requête peut réussir plus tard. Un 429 sans
+ * `Retry-After` est le plafond OTP par numéro, à l'échelle de l'heure : le rejouer
+ * ne servirait à rien. Le 501 dit une fonction non servie, jamais une panne.
+ */
+function retryDelay(failure, attempt) {
+    if (failure.status === 429)
+        return failure.retryAfter === null ? null : failure.retryAfter * 1000;
+    if (failure.code === 'idempotency_key_in_flight')
+        return backoff(attempt);
+    if (failure.status >= 500 && failure.status !== 501)
+        return backoff(attempt);
+    return null;
+}
+function backoff(attempt) {
+    return Math.min(8000, 500 * 2 ** attempt) * (1 + Math.random() * 0.25);
+}
+function defaultSleep(milliseconds) {
+    return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+function describe(cause) {
+    return cause instanceof Error ? cause.message : String(cause);
+}
+function decode(response, text) {
+    if (response.status === 204 || text.trim() === '')
+        return undefined;
+    const data = parse(text);
+    if (typeof data !== 'object' || data === null) {
+        throw new errors_js_1.ServerError("Réponse illisible de l'API.", {
+            status: response.status,
+            code: 'invalid_response',
+            type: 'api_error',
+            requestId: response.headers.get('x-request-id'),
+        });
+    }
+    return data;
+}
+function parse(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}
+function stringOrNull(value) {
+    return typeof value === 'string' ? value : null;
+}
+function toError(response, text) {
+    const decoded = parse(text);
+    const error = decoded && typeof decoded.error === 'object' && decoded.error !== null ? decoded.error : {};
+    const status = response.status;
+    const retryAfter = response.headers.get('retry-after');
+    const ErrorClass = errorClass(status);
+    return new ErrorClass(stringOrNull(error.message) ?? `Erreur HTTP ${status}.`, {
+        status,
+        code: stringOrNull(error.code) ?? `http_${status}`,
+        type: stringOrNull(error.type) ?? '',
+        param: stringOrNull(error.param),
+        requestId: stringOrNull(error.request_id) ?? response.headers.get('x-request-id'),
+        retryAfter: retryAfter !== null && /^\d+$/.test(retryAfter.trim()) ? Number(retryAfter) : null,
+    });
+}
+function errorClass(status) {
+    switch (status) {
+        case 400: return errors_js_1.InvalidRequestError;
+        case 401: return errors_js_1.AuthenticationError;
+        case 402: return errors_js_1.InsufficientBalanceError;
+        case 403: return errors_js_1.PermissionError;
+        case 404: return errors_js_1.NotFoundError;
+        case 409: return errors_js_1.ConflictError;
+        case 429: return errors_js_1.RateLimitError;
+        case 501: return errors_js_1.NotImplementedError;
+        default: return status >= 500 ? errors_js_1.ServerError : errors_js_1.ApiError;
+    }
+}

package/dist/cjs/index.d.ts

@@ -0,0 +1,7 @@
+export { DEFAULT_BASE_URL, FasterMessage } from './client.js';
+export type { FasterMessageOptions } from './client.js';
+export * from './errors.js';
+export { VERSION } from './http.js';
+export type { RequestOptions } from './http.js';
+export { Webhook } from './webhook.js';
+export type * from './types.js';

package/dist/cjs/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Webhook = exports.VERSION = exports.FasterMessage = exports.DEFAULT_BASE_URL = void 0;
+var client_js_1 = require("./client.js");
+Object.defineProperty(exports, "DEFAULT_BASE_URL", { enumerable: true, get: function () { return client_js_1.DEFAULT_BASE_URL; } });
+Object.defineProperty(exports, "FasterMessage", { enumerable: true, get: function () { return client_js_1.FasterMessage; } });
+__exportStar(require("./errors.js"), exports);
+var http_js_1 = require("./http.js");
+Object.defineProperty(exports, "VERSION", { enumerable: true, get: function () { return http_js_1.VERSION; } });
+var webhook_js_1 = require("./webhook.js");
+Object.defineProperty(exports, "Webhook", { enumerable: true, get: function () { return webhook_js_1.Webhook; } });

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{ "type": "commonjs" }

package/dist/cjs/resources.d.ts

@@ -0,0 +1,60 @@
+import type { RequestOptions, Requester } from './http.js';
+import type { Balance, Contact, ContactBatchResult, ContactGroup, ContactQuery, CreateContactBatchParams, CreateContactGroupParams, CreateContactParams, CreditMovement, CreditQuery, Message, MessageQuery, Otp, Page, PageQuery, RequestOtpParams, SendEmailParams, SendMessageParams, SendSmsBatchParams, SendSmsParams, SmsBatchResult, UpdateContactGroupParams, UpdateContactParams } from './types.js';
+export declare class Sms {
+    #private;
+    constructor(http: Requester);
+    send(params: SendSmsParams, options?: RequestOptions): Promise<Message>;
+    /** Jusqu'à 500 lignes. Lisez toujours `errors` : un retour normal ne garantit pas que toutes soient parties. */
+    sendBatch(params: SendSmsBatchParams, options?: RequestOptions): Promise<SmsBatchResult>;
+}
+export declare class Email {
+    #private;
+    constructor(http: Requester);
+    send(params: SendEmailParams, options?: RequestOptions): Promise<Message>;
+}
+export declare class Messages {
+    #private;
+    constructor(http: Requester);
+    /** Envoi avec le canal en paramètre. WhatsApp et la voix répondent aujourd'hui `501`. */
+    send(params: SendMessageParams, options?: RequestOptions): Promise<Message>;
+    get(id: string): Promise<Message>;
+    list(query?: MessageQuery): Promise<Page<Message>>;
+    all(query?: MessageQuery): AsyncGenerator<Message, void, undefined>;
+}
+export declare class OtpResource {
+    #private;
+    constructor(http: Requester);
+    request(params: RequestOtpParams, options?: RequestOptions): Promise<Otp>;
+    verify(id: string, code: string): Promise<Otp>;
+}
+export declare class Contacts {
+    #private;
+    constructor(http: Requester);
+    create(params: CreateContactParams): Promise<Contact>;
+    /** Crée jusqu'à 500 contacts dans un groupe. */
+    createBatch(params: CreateContactBatchParams, options?: RequestOptions): Promise<ContactBatchResult>;
+    get(id: string): Promise<Contact>;
+    list(query?: ContactQuery): Promise<Page<Contact>>;
+    all(query?: ContactQuery): AsyncGenerator<Contact, void, undefined>;
+    update(id: string, params: UpdateContactParams): Promise<Contact>;
+    /** Suppression définitive. Ce n'est pas un désabonnement : pour cela, `consent: 'out'`. */
+    delete(id: string): Promise<void>;
+}
+export declare class ContactGroups {
+    #private;
+    constructor(http: Requester);
+    create(params: CreateContactGroupParams): Promise<ContactGroup>;
+    get(id: string): Promise<ContactGroup>;
+    list(query?: PageQuery): Promise<Page<ContactGroup>>;
+    all(query?: PageQuery): AsyncGenerator<ContactGroup, void, undefined>;
+    update(id: string, params: UpdateContactGroupParams): Promise<ContactGroup>;
+    /** Refusé en `409` tant que le groupe contient des contacts. */
+    delete(id: string): Promise<void>;
+}
+export declare class Account {
+    #private;
+    constructor(http: Requester);
+    balance(): Promise<Balance[]>;
+    credits(query?: CreditQuery): Promise<Page<CreditMovement>>;
+    allCredits(query?: CreditQuery): AsyncGenerator<CreditMovement, void, undefined>;
+}