@voxnova/sdk 1.0.0 → 1.1.0

package/README.md

@@ -2,9 +2,10 @@
 
 SDK TypeScript de la plateforme développeurs VoxNova (Node 18+, sans dépendance).
 
-- `VoxNova` : client de l'API REST v1 (applications, endpoints SIP, numéros, appels, enregistrements, journal).
+- `VoxNova` : client de l'API REST (clé d'entreprise `vxk_…` ou clé revendeur `vxr_…`) : **SMS** (envoi, suivi de remise, crédits), webhooks, applications, endpoints SIP, numéros, appels, enregistrements, journal, **scénarios d'appel** (`flows`), utilisateurs, postes, files d'attente, groupes d'appel, serveurs vocaux, accès brut au panneau (`panel`) et **espace revendeur** (`reseller.*`, `forOrganization()`).
 - `VoiceResponse` : construction des instructions renvoyées par votre webhook (dial plan en code).
-- `verifySignature` : vérification de l'en-tête `X-VoxNova-Signature`.
+- `verifySignature` : vérification des rappels des applications vocales (`t=…,v1=…`).
+- `verifyWebhook` : vérification des webhooks d'entreprise et de revendeur (`sha256=…` : `sms.status`, `call.completed`).
 
 ```ts
 import { VoxNova, VoiceResponse, verifySignature } from '@voxnova/sdk';
@@ -17,4 +18,27 @@ const r = new VoiceResponse().say(42).gather({ numDigits: 1, action: 'https://ex
 res.json(r);
 ```
 
+```ts
+// SMS et suivi
+const sms = await vx.sms.send({ to: '0612345678', text: 'Votre code : 1234', tag: 'otp', sender: 'hCloud' });
+const state = await vx.sms.get(sms.id); // status : queued → sent → delivered ; events[]
+const { balance, monthlyLeft } = await vx.sms.balance();
+
+// Revendeur : agir au nom d'un client (clé vxr_…)
+const reseller = new VoxNova({ apiKey: process.env.VXR!, baseUrl: 'https://api.exemple.fr' });
+const client = reseller.forOrganization('<id du client>');
+await client.extensions.create({ number: '1001', displayName: 'Accueil' });
+await client.flows.create({ name: 'Standard', graph: { nodes: [/* … */], edges: [/* … */] } });
+await reseller.reseller.clients.applySmsPack('<id du client>', '<id du pack>');
+
+// Webhooks (Express) : vérifier la signature sur le corps brut
+app.post('/hook', express.raw({ type: '*/*' }), (req, res) => {
+  if (!verifyWebhook(process.env.WH_SECRET!, req.body, req.header('x-voxnova-signature'))) return res.sendStatus(401);
+  const event = JSON.parse(req.body.toString()); // { event: 'sms.status', data: { status: 'delivered', … } }
+  res.sendStatus(200);
+});
+```
+
+Documentation interactive : `/api/v1/docs` (Swagger) ; guide : chapitres 19 et 30.
+
 Documentation complète : chapitre 19 « Plateforme développeurs » et `GET /api/v1/openapi.json`.

package/dist/client.d.ts

@@ -7,7 +7,10 @@ export declare class VoxNovaError extends Error {
     constructor(message: string, status: number, body: unknown);
 }
 export interface ClientOptions {
+    /** Clé d'entreprise vxk_… ou clé revendeur vxr_… */
     apiKey: string;
+    /** Clé revendeur uniquement : identifiant (ou identifiant court) du client au nom duquel agir (en-tête X-Organization). */
+    organization?: string;
     /** Adresse du panneau, ex. https://voip.example.com */
     baseUrl: string;
     /** Délai par requête (15 s par défaut). */
@@ -69,8 +72,24 @@ export interface Endpoint {
     createdAt: string;
     registered?: boolean;
     sip?: SipCredentials;
+    /** Configuration prête pour @voxnova/webphone (softphone navigateur) ; null si la passerelle WebRTC n'est pas activée. */
+    webphone?: WebphoneConfig | null;
     registrations?: Registration[];
 }
+export interface WebphoneConfig {
+    wsServers: string[];
+    uri: string;
+    authorizationUser: string;
+    password: string;
+    realm: string;
+    displayName?: string;
+    registerExpires?: number;
+    iceServers?: {
+        urls: string | string[];
+        username?: string;
+        credential?: string;
+    }[];
+}
 export interface EndpointInput {
     number?: string;
     name: string;
@@ -104,12 +123,122 @@ export interface Page<T> {
     total: number;
     page: number;
 }
+export type Json = Record<string, unknown>;
+export interface Sms {
+    id: string;
+    to: string;
+    text: string;
+    status: 'queued' | 'sent' | 'delivered' | 'failed';
+    providerStatus: string | null;
+    messageId: string | null;
+    sender: string | null;
+    tag: string | null;
+    type: 'transactional' | 'marketing' | null;
+    segments: number;
+    channel: string | null;
+    error: string | null;
+    createdAt: string;
+    sentAt: string | null;
+    deliveredAt: string | null;
+    events?: {
+        status: string;
+        at: string;
+    }[];
+}
+export interface SmsInput {
+    to: string;
+    text: string;
+    sender?: string;
+    tag?: string;
+    type?: 'transactional' | 'marketing';
+    channel?: 'sms' | 'whatsapp' | 'auto';
+}
+export interface SmsCredits {
+    monthlyLimit: number;
+    monthlyUsed: number;
+    monthlyLeft: number;
+    balance: number;
+    available: number;
+}
+export interface SmsPack {
+    id: string;
+    name: string;
+    kind: 'MONTHLY' | 'LIFETIME';
+    credits: number;
+    priceCents: number;
+    active: boolean;
+}
+export interface SmsPackInput {
+    name: string;
+    kind: 'MONTHLY' | 'LIFETIME';
+    credits: number;
+    priceCents?: number;
+    active?: boolean;
+}
+export interface SenderBlock {
+    id: string;
+    kind: 'exact' | 'prefix' | 'contains';
+    value: string;
+    reason: string;
+}
+export interface SenderBlockInput {
+    value: string;
+    kind?: SenderBlock['kind'];
+    reason?: string;
+}
+export type WebhookEventName = 'call.completed' | 'sms.status';
+export interface Webhook {
+    id: string;
+    url: string;
+    events: WebhookEventName[];
+    enabled: boolean;
+    lastStatus: string | null;
+    createdAt: string;
+    secret?: string;
+}
+export interface WebhookInput {
+    url: string;
+    events?: WebhookEventName[];
+    enabled?: boolean;
+}
+export interface Flow {
+    id: string;
+    name: string;
+    number: string | null;
+    description: string;
+    enabled: boolean;
+    graph: {
+        nodes: Json[];
+        edges: Json[];
+    };
+    updatedAt?: string;
+}
+export interface FlowInput {
+    name: string;
+    number?: string | null;
+    description?: string;
+    enabled?: boolean;
+    graph: {
+        nodes: Json[];
+        edges: Json[];
+    };
+}
+export interface ClientInput {
+    company: string;
+    name: string;
+    email: string;
+    password: string;
+    product?: string;
+    trialDays?: number;
+}
 export declare class VoxNova {
     private readonly opts;
     private readonly base;
     private readonly f;
     constructor(opts: ClientOptions);
-    /** Requête brute vers l'API (chemin commençant par /api/v1/). */
+    /** Revendeur : client agissant au nom d'un de vos clients (même clé vxr_, en-tête X-Organization). */
+    forOrganization(organization: string): VoxNova;
+    /** Requête brute vers l'API (chemin commençant par /api/). */
     request<T>(method: string, path: string, body?: unknown, query?: Record<string, string | number | boolean | undefined>): Promise<T>;
     readonly account: {
         get: () => Promise<{
@@ -266,4 +395,193 @@ export declare class VoxNova {
             errors?: boolean;
         }) => Promise<Page<Record<string, unknown>>>;
     };
+    readonly sms: {
+        /** Met un SMS en file (statuts : webhook sms.status ou `get`). Refusé sans crédit ou si l'expéditeur est interdit. */
+        send: (input: SmsInput) => Promise<Sms>;
+        list: (opts?: {
+            page?: number;
+            pageSize?: number;
+            status?: string;
+            to?: string;
+            tag?: string;
+            since?: string;
+        }) => Promise<Page<Sms>>;
+        /** Par identifiant ou messageId du fournisseur, avec les événements de remise (accepted, sent, delivered…). */
+        get: (id: string) => Promise<Sms>;
+        /** Forfait du mois (remis à zéro chaque mois) et solde à vie. */
+        balance: () => Promise<SmsCredits>;
+    };
+    /** Webhooks de l'entreprise : call.completed, sms.status (signés, voir `verifyWebhook`). */
+    readonly webhooks: {
+        list: () => Promise<Webhook[]>;
+        /** Le secret de signature n'est renvoyé qu'à la création. */
+        create: (input: WebhookInput) => Promise<Webhook>;
+        update: (id: string, input: Partial<WebhookInput>) => Promise<Webhook>;
+        delete: (id: string) => Promise<{
+            ok: true;
+        }>;
+    };
+    /** Toute route du panneau (voir la documentation Swagger) : `vx.panel.get('/api/centrex/queues')`. */
+    readonly panel: {
+        get: <T = unknown>(path: string, query?: Record<string, string | number | boolean | undefined>) => Promise<T>;
+        post: <T = unknown>(path: string, body?: unknown) => Promise<T>;
+        put: <T = unknown>(path: string, body?: unknown) => Promise<T>;
+        patch: <T = unknown>(path: string, body?: unknown) => Promise<T>;
+        delete: <T = unknown>(path: string) => Promise<T>;
+    };
+    private crud;
+    /** Utilisateurs de l'entreprise (invitation par e-mail, droits). */
+    readonly users: {
+        invite: (id: string) => Promise<Json>;
+        permissions: (id: string, permissions: string[]) => Promise<Json>;
+        list: () => Promise<Json[]>;
+        create: (input: Json) => Promise<Json>;
+        update: (id: string, input: Partial<Json>) => Promise<Json>;
+        delete: (id: string) => Promise<{
+            ok: true;
+        }>;
+    };
+    /** Postes (extensions) : création, modification complète, mot de passe SIP, état d'enregistrement. */
+    readonly extensions: {
+        sipAccount: (id: string) => Promise<Json>;
+        resetSipPassword: (id: string) => Promise<Json>;
+        status: (id: string) => Promise<Json>;
+        list: () => Promise<Json[]>;
+        create: (input: Json) => Promise<Json>;
+        update: (id: string, input: Partial<Json>) => Promise<Json>;
+        delete: (id: string) => Promise<{
+            ok: true;
+        }>;
+    };
+    /** Scénarios d'appel (flow) : graphe de blocs, validation et simulation sans appel réel. */
+    readonly flows: {
+        list: () => Promise<Pick<Flow, "number" | "name" | "id" | "description" | "enabled">[]>;
+        get: (id: string) => Promise<Flow>;
+        create: (input: FlowInput) => Promise<Flow>;
+        update: (id: string, input: Partial<FlowInput>) => Promise<Flow>;
+        delete: (id: string) => Promise<{
+            ok: true;
+        }>;
+        validate: (graph: Flow["graph"]) => Promise<{
+            errors: string[];
+            warnings: string[];
+        }>;
+        simulate: (graph: Flow["graph"], opts?: {
+            caller?: string;
+            did?: string;
+            digits?: string[];
+        }) => Promise<Json>;
+    };
+    readonly queues: {
+        list: () => Promise<Json[]>;
+        create: (input: Json) => Promise<Json>;
+        update: (id: string, input: Partial<Json>) => Promise<Json>;
+        delete: (id: string) => Promise<{
+            ok: true;
+        }>;
+    };
+    readonly ringGroups: {
+        list: () => Promise<Json[]>;
+        create: (input: Json) => Promise<Json>;
+        update: (id: string, input: Partial<Json>) => Promise<Json>;
+        delete: (id: string) => Promise<{
+            ok: true;
+        }>;
+    };
+    readonly ivr: {
+        list: () => Promise<Json[]>;
+        create: (input: Json) => Promise<Json>;
+        update: (id: string, input: Partial<Json>) => Promise<Json>;
+        delete: (id: string) => Promise<{
+            ok: true;
+        }>;
+    };
+    readonly timeConditions: {
+        list: () => Promise<Json[]>;
+        create: (input: Json) => Promise<Json>;
+        update: (id: string, input: Partial<Json>) => Promise<Json>;
+        delete: (id: string) => Promise<{
+            ok: true;
+        }>;
+    };
+    readonly conferences: {
+        list: () => Promise<Json[]>;
+        create: (input: Json) => Promise<Json>;
+        update: (id: string, input: Partial<Json>) => Promise<Json>;
+        delete: (id: string) => Promise<{
+            ok: true;
+        }>;
+    };
+    readonly reseller: {
+        me: () => Promise<Json>;
+        clients: {
+            list: (search?: string) => Promise<Json[]>;
+            get: (id: string) => Promise<Json>;
+            create: (input: ClientInput) => Promise<Json>;
+            /** Suspension, réactivation, prolongation d'essai. */
+            update: (id: string, input: {
+                status?: "ACTIVE" | "SUSPENDED";
+                extendTrialDays?: number;
+            }) => Promise<Json>;
+            subscribe: (id: string, input: Json) => Promise<Json>;
+            sms: (id: string) => Promise<{
+                credits: SmsCredits;
+                blocks: SenderBlock[];
+            }>;
+            /** MONTHLY remplace le forfait mensuel ; LIFETIME ajoute au solde à vie. */
+            applySmsPack: (id: string, packId: string) => Promise<SmsCredits>;
+            blockSender: (id: string, input: SenderBlockInput) => Promise<SenderBlock>;
+        };
+        catalog: () => Promise<Json>;
+        plans: {
+            list: () => Promise<Json[]>;
+            create: (input: Json) => Promise<Json>;
+            update: (id: string, input: Partial<Json>) => Promise<Json>;
+            delete: (id: string) => Promise<{
+                ok: true;
+            }>;
+        };
+        invoices: {
+            list: () => Promise<Json[]>;
+            validate: (id: string, input?: Json) => Promise<Json>;
+            cancel: (id: string, input?: Json) => Promise<Json>;
+        };
+        smsPacks: {
+            list: () => Promise<SmsPack[]>;
+            create: (input: SmsPackInput) => Promise<SmsPack>;
+            update: (id: string, input: Partial<SmsPackInput>) => Promise<SmsPack>;
+            delete: (id: string) => Promise<{
+                ok: true;
+            }>;
+        };
+        senderBlocks: {
+            list: () => Promise<SenderBlock[]>;
+            create: (input: SenderBlockInput) => Promise<SenderBlock>;
+            delete: (id: string) => Promise<{
+                ok: true;
+            }>;
+        };
+        /** SMS de tous vos clients. */
+        sms: (opts?: {
+            orgId?: string;
+            status?: string;
+            page?: number;
+        }) => Promise<{
+            total: number;
+            items: Json[];
+        }>;
+        /** Webhooks recevant les événements de tous vos clients (sms.status). */
+        webhooks: {
+            list: () => Promise<Webhook[]>;
+            create: (input: {
+                url: string;
+                events?: "sms.status"[];
+                enabled?: boolean;
+            }) => Promise<Webhook>;
+            update: (id: string, input: Partial<WebhookInput>) => Promise<Webhook>;
+            delete: (id: string) => Promise<{
+                ok: true;
+            }>;
+        };
+    };
 }

package/dist/client.js

@@ -11,24 +11,29 @@ export class VoxNovaError extends Error {
         this.name = 'VoxNovaError';
     }
 }
+const q = encodeURIComponent;
 export class VoxNova {
     opts;
     base;
     f;
     constructor(opts) {
         this.opts = opts;
-        if (!opts.apiKey?.startsWith('vxk_'))
-            throw new Error('Clé API vxk_… requise');
+        if (!opts.apiKey?.startsWith('vxk_') && !opts.apiKey?.startsWith('vxr_'))
+            throw new Error('Clé API vxk_… (entreprise) ou vxr_… (revendeur) requise');
         this.base = opts.baseUrl.replace(/\/+$/, '');
         this.f = opts.fetch ?? fetch;
     }
-    /** Requête brute vers l'API (chemin commençant par /api/v1/). */
+    /** Revendeur : client agissant au nom d'un de vos clients (même clé vxr_, en-tête X-Organization). */
+    forOrganization(organization) {
+        return new VoxNova({ ...this.opts, organization });
+    }
+    /** Requête brute vers l'API (chemin commençant par /api/). */
     async request(method, path, body, query) {
         const qs = query ? Object.entries(query).filter(([, v]) => v !== undefined).map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`).join('&') : '';
         const isForm = typeof FormData !== 'undefined' && body instanceof FormData;
         const res = await this.f(`${this.base}${path}${qs ? `?${qs}` : ''}`, {
             method,
-            headers: { Authorization: `Bearer ${this.opts.apiKey}`, Accept: 'application/json', ...(body && !isForm ? { 'Content-Type': 'application/json' } : {}) },
+            headers: { Authorization: `Bearer ${this.opts.apiKey}`, Accept: 'application/json', ...(this.opts.organization ? { 'X-Organization': this.opts.organization } : {}), ...(body && !isForm ? { 'Content-Type': 'application/json' } : {}) },
             body: body === undefined ? undefined : isForm ? body : JSON.stringify(body),
             signal: AbortSignal.timeout(this.opts.timeoutMs ?? 15000),
         });
@@ -107,4 +112,83 @@ export class VoxNova {
     logs = {
         list: (opts = {}) => this.request('GET', '/api/v1/logs', undefined, opts),
     };
+    // ---------------------------------------------------------------- SMS
+    sms = {
+        /** Met un SMS en file (statuts : webhook sms.status ou `get`). Refusé sans crédit ou si l'expéditeur est interdit. */
+        send: (input) => this.request('POST', '/api/v1/sms', input),
+        list: (opts = {}) => this.request('GET', '/api/v1/sms', undefined, opts),
+        /** Par identifiant ou messageId du fournisseur, avec les événements de remise (accepted, sent, delivered…). */
+        get: (id) => this.request('GET', `/api/v1/sms/${q(id)}`),
+        /** Forfait du mois (remis à zéro chaque mois) et solde à vie. */
+        balance: () => this.request('GET', '/api/v1/sms/balance'),
+    };
+    /** Webhooks de l'entreprise : call.completed, sms.status (signés, voir `verifyWebhook`). */
+    webhooks = {
+        list: () => this.request('GET', '/api/v1/webhooks'),
+        /** Le secret de signature n'est renvoyé qu'à la création. */
+        create: (input) => this.request('POST', '/api/v1/webhooks', input),
+        update: (id, input) => this.request('PATCH', `/api/v1/webhooks/${q(id)}`, input),
+        delete: (id) => this.request('DELETE', `/api/v1/webhooks/${q(id)}`),
+    };
+    // ---------------------------------------------------------------- panneau d'une entreprise (clé revendeur + organization)
+    /** Toute route du panneau (voir la documentation Swagger) : `vx.panel.get('/api/centrex/queues')`. */
+    panel = {
+        get: (path, query) => this.request('GET', path, undefined, query),
+        post: (path, body) => this.request('POST', path, body ?? {}),
+        put: (path, body) => this.request('PUT', path, body ?? {}),
+        patch: (path, body) => this.request('PATCH', path, body ?? {}),
+        delete: (path) => this.request('DELETE', path),
+    };
+    crud(base, update = 'PUT') {
+        return {
+            list: () => this.request('GET', base),
+            create: (input) => this.request('POST', base, input),
+            update: (id, input) => this.request(update, `${base}/${q(id)}`, input),
+            delete: (id) => this.request('DELETE', `${base}/${q(id)}`),
+        };
+    }
+    /** Utilisateurs de l'entreprise (invitation par e-mail, droits). */
+    users = { ...this.crud('/api/org/users', 'PATCH'), invite: (id) => this.request('POST', `/api/org/users/${q(id)}/invite`, {}), permissions: (id, permissions) => this.request('PUT', `/api/org/users/${q(id)}/permissions`, { permissions }) };
+    /** Postes (extensions) : création, modification complète, mot de passe SIP, état d'enregistrement. */
+    extensions = { ...this.crud('/api/org/extensions'), sipAccount: (id) => this.request('GET', `/api/org/extensions/${q(id)}/sip-account`), resetSipPassword: (id) => this.request('POST', `/api/org/extensions/${q(id)}/sip-password`, {}), status: (id) => this.request('GET', `/api/org/extensions/${q(id)}/status`) };
+    /** Scénarios d'appel (flow) : graphe de blocs, validation et simulation sans appel réel. */
+    flows = {
+        list: () => this.request('GET', '/api/centrex/flows'),
+        get: (id) => this.request('GET', `/api/centrex/flows/${q(id)}`),
+        create: (input) => this.request('POST', '/api/centrex/flows', input),
+        update: (id, input) => this.request('PUT', `/api/centrex/flows/${q(id)}`, input),
+        delete: (id) => this.request('DELETE', `/api/centrex/flows/${q(id)}`),
+        validate: (graph) => this.request('POST', '/api/centrex/flows/validate', { graph }),
+        simulate: (graph, opts = {}) => this.request('POST', '/api/centrex/flows/simulate', { graph, ...opts }),
+    };
+    queues = this.crud('/api/centrex/queues');
+    ringGroups = this.crud('/api/centrex/ring-groups');
+    ivr = this.crud('/api/centrex/ivr');
+    timeConditions = this.crud('/api/centrex/time-conditions');
+    conferences = this.crud('/api/centrex/conferences');
+    // ---------------------------------------------------------------- revendeur (clé vxr_)
+    reseller = {
+        me: () => this.request('GET', '/api/reseller/me'),
+        clients: {
+            list: (search) => this.request('GET', '/api/reseller/clients', undefined, { q: search }),
+            get: (id) => this.request('GET', `/api/reseller/clients/${q(id)}`),
+            create: (input) => this.request('POST', '/api/reseller/clients', input),
+            /** Suspension, réactivation, prolongation d'essai. */
+            update: (id, input) => this.request('PATCH', `/api/reseller/clients/${q(id)}`, input),
+            subscribe: (id, input) => this.request('POST', `/api/reseller/clients/${q(id)}/subscription`, input),
+            sms: (id) => this.request('GET', `/api/reseller/clients/${q(id)}/sms`),
+            /** MONTHLY remplace le forfait mensuel ; LIFETIME ajoute au solde à vie. */
+            applySmsPack: (id, packId) => this.request('POST', `/api/reseller/clients/${q(id)}/sms/pack`, { packId }),
+            blockSender: (id, input) => this.request('POST', `/api/reseller/clients/${q(id)}/sms/sender-blocks`, input),
+        },
+        catalog: () => this.request('GET', '/api/reseller/catalog'),
+        plans: this.crud('/api/reseller/plans'),
+        invoices: { list: () => this.request('GET', '/api/reseller/invoices'), validate: (id, input = {}) => this.request('POST', `/api/reseller/invoices/${q(id)}/validate`, input), cancel: (id, input = {}) => this.request('POST', `/api/reseller/invoices/${q(id)}/cancel`, input) },
+        smsPacks: this.crud('/api/reseller/sms/packs'),
+        senderBlocks: { list: () => this.request('GET', '/api/reseller/sms/sender-blocks'), create: (input) => this.request('POST', '/api/reseller/sms/sender-blocks', input), delete: (id) => this.request('DELETE', `/api/reseller/sms/sender-blocks/${q(id)}`) },
+        /** SMS de tous vos clients. */
+        sms: (opts = {}) => this.request('GET', '/api/reseller/sms', undefined, opts),
+        /** Webhooks recevant les événements de tous vos clients (sms.status). */
+        webhooks: { list: () => this.request('GET', '/api/reseller/webhooks'), create: (input) => this.request('POST', '/api/reseller/webhooks', input), update: (id, input) => this.request('PATCH', `/api/reseller/webhooks/${q(id)}`, input), delete: (id) => this.request('DELETE', `/api/reseller/webhooks/${q(id)}`) },
+    };
 }

package/dist/index.d.ts

@@ -1,2 +1,3 @@
 export * from './client.js';
 export * from './voice.js';
+export * from './webhook.js';

package/dist/index.js

@@ -1,2 +1,3 @@
 export * from './client.js';
 export * from './voice.js';
+export * from './webhook.js';

package/dist/webhook.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Événements des webhooks d'entreprise ou de revendeur (call.completed, sms.status) : en-têtes
+ * `X-VoxNova-Event` et `X-VoxNova-Signature: sha256=<HMAC-SHA256 du corps brut avec le secret du webhook>`.
+ * (Les rappels des applications vocales utilisent `verifySignature`, au format `t=…,v1=…`.)
+ */
+export interface SmsStatusEvent {
+    event: 'sms.status';
+    createdAt: string;
+    data: {
+        id: string;
+        orgId: string;
+        to: string;
+        status: string;
+        messageId: string | null;
+        tag: string | null;
+        type: string | null;
+        segments: number;
+        sender: string | null;
+        error: string | null;
+        at: string;
+    };
+}
+export declare function verifyWebhook(secret: string, rawBody: string | Buffer, header: string | undefined | null): boolean;

package/dist/webhook.js

@@ -0,0 +1,8 @@
+import { createHmac, timingSafeEqual } from 'node:crypto';
+export function verifyWebhook(secret, rawBody, header) {
+    if (!header?.startsWith('sha256='))
+        return false;
+    const expected = createHmac('sha256', secret).update(rawBody).digest();
+    const got = Buffer.from(header.slice(7), 'hex');
+    return got.length === expected.length && timingSafeEqual(got, expected);
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@voxnova/sdk",
-  "version": "1.0.0",
-  "description": "SDK TypeScript de la plateforme développeurs VoxNova : API REST, instructions vocales (dial plan en code), vérification des webhooks",
+  "version": "1.1.0",
+  "description": "SDK TypeScript de la plateforme VoxNova : API REST (SMS, endpoints, numéros, appels, scénarios d'appel, espace revendeur), instructions vocales, vérification des webhooks",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -17,7 +17,8 @@
   ],
   "scripts": {
     "build": "tsc -p tsconfig.json",
-    "typecheck": "tsc --noEmit -p tsconfig.json"
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "test": "node --test test/*.test.mjs"
   },
   "engines": {
     "node": ">=18"