@voxnova/sdk 0.0.0-stage → 1.0.0

package/README.md

@@ -1,3 +1,20 @@
-# Temporary Holding Version
+# @voxnova/sdk
 
-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 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).
+- `VoiceResponse` : construction des instructions renvoyées par votre webhook (dial plan en code).
+- `verifySignature` : vérification de l'en-tête `X-VoxNova-Signature`.
+
+```ts
+import { VoxNova, VoiceResponse, verifySignature } from '@voxnova/sdk';
+
+const vx = new VoxNova({ apiKey: process.env.VX_KEY!, baseUrl: 'https://voip.exemple.fr' });
+const ep = await vx.endpoints.create({ name: 'Accueil' });
+
+// dans votre webhook
+const r = new VoiceResponse().say(42).gather({ numDigits: 1, action: 'https://exemple.fr/menu' });
+res.json(r);
+```
+
+Documentation complète : chapitre 19 « Plateforme développeurs » et `GET /api/v1/openapi.json`.

package/dist/client.d.ts

@@ -0,0 +1,269 @@
+/**
+ * Client de l'API REST v1 (clé API vxk_…).
+ */
+export declare class VoxNovaError extends Error {
+    readonly status: number;
+    readonly body: unknown;
+    constructor(message: string, status: number, body: unknown);
+}
+export interface ClientOptions {
+    apiKey: string;
+    /** Adresse du panneau, ex. https://voip.example.com */
+    baseUrl: string;
+    /** Délai par requête (15 s par défaut). */
+    timeoutMs?: number;
+    fetch?: typeof fetch;
+}
+export interface Application {
+    id: string;
+    name: string;
+    voiceUrl: string;
+    fallbackUrl: string | null;
+    statusCallbackUrl: string | null;
+    signingSecret: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface ApplicationInput {
+    name: string;
+    voiceUrl: string;
+    fallbackUrl?: string | null;
+    statusCallbackUrl?: string | null;
+}
+export interface Registration {
+    user: string;
+    agent: string;
+    ip: string;
+    port: string;
+    status: string;
+    contact: string;
+}
+export interface SipCredentials {
+    username: string;
+    authUsername: string;
+    password: string;
+    domain: string;
+    server: string;
+    port: number;
+    transports: string[];
+    outboundProxy: string;
+    voicemailNumber: string;
+    codecs: string[];
+}
+export interface Endpoint {
+    id: string;
+    number: string;
+    name: string;
+    enabled: boolean;
+    applicationId: string | null;
+    voicemail: boolean;
+    callerId: string | null;
+    permission: 'INTERNAL' | 'NATIONAL' | 'INTERNATIONAL';
+    recordCalls: boolean;
+    forward: {
+        always: string | null;
+        busy: string | null;
+        noAnswer: string | null;
+        noAnswerSeconds: number;
+    };
+    createdAt: string;
+    registered?: boolean;
+    sip?: SipCredentials;
+    registrations?: Registration[];
+}
+export interface EndpointInput {
+    number?: string;
+    name: string;
+    applicationId?: string | null;
+    password?: string;
+    voicemail?: boolean;
+    callerId?: string | null;
+    permission?: Endpoint['permission'];
+    recordCalls?: boolean;
+    enabled?: boolean;
+    forward?: Partial<Endpoint['forward']>;
+}
+export interface PhoneNumber {
+    number: string;
+    label: string;
+    destType: string | null;
+    routing: Record<string, string> | null;
+    monthlyPriceCents: number;
+    createdAt: string;
+}
+export interface CallInput {
+    to: string;
+    applicationId: string;
+    from?: string;
+    url?: string;
+    timeout?: number;
+    vars?: Record<string, string | number | boolean>;
+}
+export interface Page<T> {
+    items: T[];
+    total: number;
+    page: 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/). */
+    request<T>(method: string, path: string, body?: unknown, query?: Record<string, string | number | boolean | undefined>): Promise<T>;
+    readonly account: {
+        get: () => Promise<{
+            id: string;
+            name: string;
+            product: string;
+            status: string;
+            sipDomain: string;
+            limits: {
+                endpoints: number;
+                numbers: number;
+                channels: number | null;
+            };
+            usage: {
+                endpoints: number;
+                numbers: number;
+                applications: number;
+            };
+        }>;
+        usage: () => Promise<{
+            month: string;
+            label: string;
+            lines: {
+                label: string;
+                quantity: number;
+                unitCents: number;
+                totalCents: number;
+            }[];
+            subtotalCents: number;
+        }>;
+    };
+    readonly applications: {
+        list: () => Promise<Application[]>;
+        create: (input: ApplicationInput) => Promise<Application>;
+        get: (id: string) => Promise<Application>;
+        update: (id: string, input: Partial<ApplicationInput>) => Promise<Application>;
+        rotateSecret: (id: string) => Promise<Application>;
+        delete: (id: string) => Promise<{
+            ok: true;
+        }>;
+    };
+    readonly endpoints: {
+        list: () => Promise<Endpoint[]>;
+        create: (input: EndpointInput) => Promise<Endpoint>;
+        /** Par identifiant ou numéro interne ; inclut les identifiants SIP et les appareils enregistrés. */
+        get: (id: string) => Promise<Endpoint>;
+        update: (id: string, input: Partial<EndpointInput>) => Promise<Endpoint>;
+        registrations: (id: string) => Promise<Registration[]>;
+        resetPassword: (id: string) => Promise<Endpoint>;
+        disconnect: (id: string) => Promise<{
+            ok: true;
+        }>;
+        delete: (id: string) => Promise<{
+            ok: true;
+        }>;
+    };
+    readonly numbers: {
+        list: () => Promise<PhoneNumber[]>;
+        available: (opts?: {
+            contains?: string;
+            limit?: number;
+        }) => Promise<{
+            number: string;
+            monthlyPriceCents: number;
+        }[]>;
+        buy: (number: string, opts?: {
+            applicationId?: string;
+            label?: string;
+        }) => Promise<PhoneNumber>;
+        /** Relie le numéro à une application ou à un endpoint (null pour détacher). */
+        route: (number: string, to: {
+            applicationId?: string | null;
+            endpointId?: string | null;
+            label?: string;
+        }) => Promise<PhoneNumber>;
+        release: (number: string) => Promise<{
+            ok: true;
+        }>;
+    };
+    readonly calls: {
+        /** Appelle un endpoint ou un numéro ; au décroché, l'application prend la main (direction « api »). */
+        create: (input: CallInput) => Promise<{
+            callId: string;
+            status: string;
+            to: string;
+            from: string | null;
+            applicationId: string;
+        }>;
+        live: () => Promise<{
+            online: boolean;
+            calls: Record<string, unknown>[];
+        }>;
+        get: (id: string) => Promise<Record<string, unknown> & {
+            status: "in-progress" | "completed";
+        }>;
+        hangup: (id: string) => Promise<{
+            ok: true;
+        }>;
+        /** Reprend la main sur un appel en cours : `url` reçoit l'événement « redirect ». */
+        redirect: (id: string, opts?: {
+            url?: string;
+            applicationId?: string;
+        }) => Promise<{
+            ok: true;
+        }>;
+    };
+    readonly cdr: {
+        list: (opts?: {
+            page?: number;
+            pageSize?: number;
+            since?: string;
+        }) => Promise<Page<Record<string, unknown>>>;
+    };
+    readonly recordings: {
+        list: (opts?: {
+            page?: number;
+            pageSize?: number;
+            callId?: string;
+        }) => Promise<Page<{
+            id: string;
+            callId: string;
+            applicationId: string | null;
+            durationSec: number;
+            createdAt: string;
+        }>>;
+        /** Lien d'écoute signé (5 minutes) : le fichier reste sur la plateforme. */
+        url: (id: string) => Promise<{
+            url: string;
+            expiresIn: number;
+        }>;
+        delete: (id: string) => Promise<{
+            ok: true;
+        }>;
+    };
+    readonly audio: {
+        list: () => Promise<{
+            id: string;
+            name: string;
+            durationSec: number;
+        }[]>;
+        /** Envoie un fichier audio (MP3, WAV, AAC, M4A, OGG…) utilisable avec play({ audioId }). */
+        upload: (file: Blob, name?: string) => Promise<{
+            id: string;
+            name: string;
+            durationSec: number;
+        }>;
+    };
+    readonly logs: {
+        list: (opts?: {
+            page?: number;
+            pageSize?: number;
+            callId?: string;
+            applicationId?: string;
+            errors?: boolean;
+        }) => Promise<Page<Record<string, unknown>>>;
+    };
+}

package/dist/client.js

@@ -0,0 +1,110 @@
+/**
+ * Client de l'API REST v1 (clé API vxk_…).
+ */
+export class VoxNovaError extends Error {
+    status;
+    body;
+    constructor(message, status, body) {
+        super(message);
+        this.status = status;
+        this.body = body;
+        this.name = 'VoxNovaError';
+    }
+}
+export class VoxNova {
+    opts;
+    base;
+    f;
+    constructor(opts) {
+        this.opts = opts;
+        if (!opts.apiKey?.startsWith('vxk_'))
+            throw new Error('Clé API vxk_… requise');
+        this.base = opts.baseUrl.replace(/\/+$/, '');
+        this.f = opts.fetch ?? fetch;
+    }
+    /** Requête brute vers l'API (chemin commençant par /api/v1/). */
+    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' } : {}) },
+            body: body === undefined ? undefined : isForm ? body : JSON.stringify(body),
+            signal: AbortSignal.timeout(this.opts.timeoutMs ?? 15000),
+        });
+        const text = await res.text();
+        let json = null;
+        try {
+            json = text ? JSON.parse(text) : null;
+        }
+        catch {
+            json = text;
+        }
+        if (!res.ok)
+            throw new VoxNovaError(json?.error ?? `HTTP ${res.status}`, res.status, json);
+        return json;
+    }
+    account = {
+        get: () => this.request('GET', '/api/v1/account'),
+        usage: () => this.request('GET', '/api/v1/usage'),
+    };
+    applications = {
+        list: () => this.request('GET', '/api/v1/applications'),
+        create: (input) => this.request('POST', '/api/v1/applications', input),
+        get: (id) => this.request('GET', `/api/v1/applications/${id}`),
+        update: (id, input) => this.request('PATCH', `/api/v1/applications/${id}`, input),
+        rotateSecret: (id) => this.request('POST', `/api/v1/applications/${id}/secret`),
+        delete: (id) => this.request('DELETE', `/api/v1/applications/${id}`),
+    };
+    endpoints = {
+        list: () => this.request('GET', '/api/v1/endpoints'),
+        create: (input) => this.request('POST', '/api/v1/endpoints', input),
+        /** Par identifiant ou numéro interne ; inclut les identifiants SIP et les appareils enregistrés. */
+        get: (id) => this.request('GET', `/api/v1/endpoints/${encodeURIComponent(id)}`),
+        update: (id, input) => this.request('PATCH', `/api/v1/endpoints/${encodeURIComponent(id)}`, input),
+        registrations: (id) => this.request('GET', `/api/v1/endpoints/${encodeURIComponent(id)}/registrations`),
+        resetPassword: (id) => this.request('POST', `/api/v1/endpoints/${encodeURIComponent(id)}/password`),
+        disconnect: (id) => this.request('POST', `/api/v1/endpoints/${encodeURIComponent(id)}/disconnect`),
+        delete: (id) => this.request('DELETE', `/api/v1/endpoints/${encodeURIComponent(id)}`),
+    };
+    numbers = {
+        list: () => this.request('GET', '/api/v1/numbers'),
+        available: (opts = {}) => this.request('GET', '/api/v1/numbers/available', undefined, opts),
+        buy: (number, opts = {}) => this.request('POST', '/api/v1/numbers', { number, ...opts }),
+        /** Relie le numéro à une application ou à un endpoint (null pour détacher). */
+        route: (number, to) => this.request('PATCH', `/api/v1/numbers/${encodeURIComponent(number)}`, to),
+        release: (number) => this.request('DELETE', `/api/v1/numbers/${encodeURIComponent(number)}`),
+    };
+    calls = {
+        /** Appelle un endpoint ou un numéro ; au décroché, l'application prend la main (direction « api »). */
+        create: (input) => this.request('POST', '/api/v1/calls', input),
+        live: () => this.request('GET', '/api/v1/calls'),
+        get: (id) => this.request('GET', `/api/v1/calls/${id}`),
+        hangup: (id) => this.request('POST', `/api/v1/calls/${id}/hangup`),
+        /** Reprend la main sur un appel en cours : `url` reçoit l'événement « redirect ». */
+        redirect: (id, opts = {}) => this.request('POST', `/api/v1/calls/${id}/redirect`, opts),
+    };
+    cdr = {
+        list: (opts = {}) => this.request('GET', '/api/v1/cdr', undefined, opts),
+    };
+    recordings = {
+        list: (opts = {}) => this.request('GET', '/api/v1/recordings', undefined, opts),
+        /** Lien d'écoute signé (5 minutes) : le fichier reste sur la plateforme. */
+        url: (id) => this.request('POST', `/api/v1/recordings/${id}/url`),
+        delete: (id) => this.request('DELETE', `/api/v1/recordings/${id}`),
+    };
+    audio = {
+        list: () => this.request('GET', '/api/v1/audio'),
+        /** Envoie un fichier audio (MP3, WAV, AAC, M4A, OGG…) utilisable avec play({ audioId }). */
+        upload: (file, name) => {
+            const form = new FormData();
+            if (name)
+                form.append('name', name);
+            form.append('file', file, name ?? 'audio');
+            return this.request('POST', '/api/v1/audio', form);
+        },
+    };
+    logs = {
+        list: (opts = {}) => this.request('GET', '/api/v1/logs', undefined, opts),
+    };
+}

package/dist/index.d.ts

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

package/dist/index.js

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

package/dist/voice.d.ts

@@ -0,0 +1,151 @@
+/**
+ * Instructions vocales (dial plan en code) : votre webhook répond par une liste JSON d'instructions,
+ * construite ici avec VoiceResponse.
+ */
+export type Verb = {
+    verb: string;
+    [key: string]: unknown;
+};
+export interface AudioSource {
+    /** Fichier audio distant (MP3, WAV, AAC, M4A, OGG…), converti et mis en cache par la plateforme. */
+    url?: string;
+    /** Fichier audio envoyé par l'API (/api/v1/audio). */
+    audioId?: string;
+    /** Son intégré du moteur, ex. « ivr/ivr-welcome.wav ». */
+    sound?: string;
+}
+export interface GatherOptions extends AudioSource {
+    /** Nombre exact de chiffres attendus (raccourci pour minDigits = maxDigits). */
+    numDigits?: number;
+    minDigits?: number;
+    maxDigits?: number;
+    /** Délai d'attente de la première touche, en secondes (5 par défaut). */
+    timeout?: number;
+    /** Délai entre deux touches, en secondes (3 par défaut). */
+    interDigitTimeout?: number;
+    /** Touche de fin de saisie : « # » (par défaut), « * » ou « » (aucune). */
+    finishOnKey?: '#' | '*' | '';
+    /** Nombre d'essais (annonce rejouée). */
+    tries?: number;
+    /** URL rappelée avec `digits` (par défaut : l'URL qui a produit ces instructions). */
+    action?: string;
+}
+export interface RecordOptions {
+    maxSeconds?: number;
+    /** Fin automatique après N secondes de silence (5 par défaut). */
+    silenceSeconds?: number;
+    beep?: boolean;
+    finishOnKey?: string;
+    /** URL rappelée avec `recording: { id, duration }`. */
+    action?: string;
+}
+export type DialTarget = {
+    endpoint: string;
+} | {
+    number: string;
+};
+export interface DialOptions {
+    /** Délai de sonnerie en secondes (30 par défaut). */
+    timeout?: number;
+    /** Numéro présenté (l'un de vos numéros). */
+    callerId?: string;
+    /** Plusieurs destinations : en même temps (par défaut) ou l'une après l'autre. */
+    strategy?: 'simultaneous' | 'sequential';
+    /** Enregistrer la communication. */
+    record?: boolean;
+    /** URL rappelée avec `dial: { status, answered, hangupCause }` à la fin (sinon l'appel se termine s'il a abouti). */
+    action?: string;
+}
+export interface ConferenceOptions {
+    muted?: boolean;
+    moderator?: boolean;
+    endOnExit?: boolean;
+    waitForModerator?: boolean;
+    beep?: boolean;
+}
+export declare class VoiceResponse {
+    private readonly verbs;
+    private push;
+    answer(): this;
+    /** Joue un fichier audio (URL, fichier envoyé ou son intégré). */
+    play(source: string | AudioSource, opts?: {
+        loop?: number;
+    }): this;
+    /** Prononce un nombre (« quarante-deux ») ou ses chiffres un par un. */
+    say(value: string | number, opts?: {
+        as?: 'number' | 'digits';
+        language?: 'fr' | 'en';
+    }): this;
+    pause(seconds?: number): this;
+    /** Variables de l'appel, renvoyées dans chaque webhook (`vars`). */
+    set(vars: Record<string, string | number | boolean>): this;
+    gather(opts?: GatherOptions): this;
+    record(opts?: RecordOptions): this;
+    /** Appelle un endpoint SIP, un numéro, ou plusieurs destinations. */
+    dial(target: DialTarget | DialTarget[], opts?: DialOptions): this;
+    /** Redemande des instructions à une autre URL. */
+    redirect(url: string): this;
+    /** File d'attente (identifiant ou numéro interne). */
+    queue(queue: string): this;
+    /** Conférence nommée (créée à la première arrivée). */
+    conference(name: string, opts?: ConferenceOptions): this;
+    /** Messagerie vocale d'un endpoint. */
+    voicemail(endpoint: string): this;
+    /** Transfert vers un numéro interne (poste, groupe, standard vocal…) ou externe. */
+    transfer(to: string): this;
+    hangup(cause?: string): this;
+    toJSON(): Verb[];
+    toString(): string;
+}
+export type WebhookEvent = 'call.incoming' | 'gather' | 'dial' | 'record' | 'redirect';
+/** Corps des requêtes envoyées à votre voiceUrl et à vos URL d'action. */
+export interface VoiceRequest {
+    event: WebhookEvent;
+    callId: string;
+    applicationId: string;
+    accountId: string;
+    /** inbound : appel reçu sur un numéro ; endpoint : appel émis par un endpoint ; api : appel lancé par l'API. */
+    direction: 'inbound' | 'endpoint' | 'api';
+    from: string;
+    to: string;
+    callerName: string;
+    /** Endpoint à l'origine de l'appel (direction « endpoint »). */
+    endpoint?: string;
+    vars: Record<string, string>;
+    timestamp: string;
+    digits?: string;
+    dial?: {
+        status: 'completed' | 'busy' | 'no-answer' | 'canceled' | 'failed';
+        answered: boolean;
+        hangupCause: string;
+    };
+    recording?: {
+        id: string;
+        duration: number;
+    } | null;
+    /** Présent quand la requête est envoyée à l'URL de secours. */
+    fallback?: boolean;
+    error?: string;
+}
+/** Corps envoyé à statusCallbackUrl à la fin de l'appel. */
+export interface StatusCallback {
+    event: 'call.completed';
+    callId: string;
+    applicationId: string;
+    accountId: string;
+    direction: string;
+    from: string;
+    to: string;
+    startedAt: string;
+    answeredAt: string | null;
+    endedAt: string;
+    duration: number;
+    billsec: number;
+    hangupCause: string | null;
+    costCents: number;
+}
+/**
+ * Vérifie l'en-tête X-VoxNova-Signature (« t=<horodatage>,v1=<HMAC-SHA256 hex> ») sur le corps brut de la requête.
+ * Refuse les requêtes de plus de `toleranceSec` secondes (rejeu).
+ */
+export declare function verifySignature(secret: string, rawBody: string | Buffer, header: string | undefined | null, toleranceSec?: number): boolean;

package/dist/voice.js

@@ -0,0 +1,80 @@
+import { createHmac, timingSafeEqual } from 'node:crypto';
+export class VoiceResponse {
+    verbs = [];
+    push(verb, data = {}) {
+        this.verbs.push({ verb, ...Object.fromEntries(Object.entries(data).filter(([, v]) => v !== undefined)) });
+        return this;
+    }
+    answer() {
+        return this.push('answer');
+    }
+    /** Joue un fichier audio (URL, fichier envoyé ou son intégré). */
+    play(source, opts = {}) {
+        return this.push('play', { ...(typeof source === 'string' ? { url: source } : source), ...opts });
+    }
+    /** Prononce un nombre (« quarante-deux ») ou ses chiffres un par un. */
+    say(value, opts = {}) {
+        return this.push('say', { value: String(value), ...opts });
+    }
+    pause(seconds = 1) {
+        return this.push('pause', { seconds });
+    }
+    /** Variables de l'appel, renvoyées dans chaque webhook (`vars`). */
+    set(vars) {
+        return this.push('set', { vars });
+    }
+    gather(opts = {}) {
+        return this.push('gather', { ...opts });
+    }
+    record(opts = {}) {
+        return this.push('record', { ...opts });
+    }
+    /** Appelle un endpoint SIP, un numéro, ou plusieurs destinations. */
+    dial(target, opts = {}) {
+        return this.push('dial', { ...(Array.isArray(target) ? { targets: target } : target), ...opts });
+    }
+    /** Redemande des instructions à une autre URL. */
+    redirect(url) {
+        return this.push('redirect', { url });
+    }
+    /** File d'attente (identifiant ou numéro interne). */
+    queue(queue) {
+        return this.push('queue', { queue });
+    }
+    /** Conférence nommée (créée à la première arrivée). */
+    conference(name, opts = {}) {
+        return this.push('conference', { name, ...opts });
+    }
+    /** Messagerie vocale d'un endpoint. */
+    voicemail(endpoint) {
+        return this.push('voicemail', { endpoint });
+    }
+    /** Transfert vers un numéro interne (poste, groupe, standard vocal…) ou externe. */
+    transfer(to) {
+        return this.push('transfer', { to });
+    }
+    hangup(cause) {
+        return this.push('hangup', { cause });
+    }
+    toJSON() {
+        return this.verbs;
+    }
+    toString() {
+        return JSON.stringify(this.verbs);
+    }
+}
+/**
+ * Vérifie l'en-tête X-VoxNova-Signature (« t=<horodatage>,v1=<HMAC-SHA256 hex> ») sur le corps brut de la requête.
+ * Refuse les requêtes de plus de `toleranceSec` secondes (rejeu).
+ */
+export function verifySignature(secret, rawBody, header, toleranceSec = 300) {
+    if (!header)
+        return false;
+    const parts = Object.fromEntries(header.split(',').map((p) => p.trim().split('=', 2)));
+    const ts = Number(parts.t);
+    if (!ts || !parts.v1 || Math.abs(Date.now() / 1000 - ts) > toleranceSec)
+        return false;
+    const expected = Buffer.from(createHmac('sha256', secret).update(`${ts}.${rawBody.toString()}`).digest('hex'));
+    const given = Buffer.from(parts.v1);
+    return expected.length === given.length && timingSafeEqual(expected, given);
+}

package/package.json

@@ -1,6 +1,39 @@
 {
   "name": "@voxnova/sdk",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "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",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc --noEmit -p tsconfig.json"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/damidani/voxnova.git",
+    "directory": "packages/sdk"
+  },
+  "keywords": [
+    "voip",
+    "sip",
+    "telephony",
+    "webhooks",
+    "ivr",
+    "voxnova"
+  ]
+}