@vuevox/sdk 0.3.0 → 0.4.0

package/README.md

@@ -23,6 +23,8 @@ Available scopes:
 ```text
 hello:read
 spaces:read
+calls:read
+leads:read
 ```
 
 ## Basic Usage
@@ -33,16 +35,20 @@ import { createVueVoxClient } from "@vuevox/sdk";
 const vuevox = createVueVoxClient({
   clientId: process.env.VUEVOX_CLIENT_ID!,
   clientSecret: process.env.VUEVOX_CLIENT_SECRET!,
-  scope: ["hello:read", "spaces:read"],
+  scope: ["hello:read", "spaces:read", "calls:read", "leads:read"],
 });
 
-const hello = await vuevox.hello();
-console.log(hello.data.message);
-console.log(hello.requestId);
+const hello = await vuevox.hello.get();
+console.log(hello.data.message, hello.requestId);
 
-const spaces = await vuevox.listSpaces({ limit: 50 });
-console.log(spaces.data.data);
-console.log(spaces.requestId);
+const spaces = await vuevox.spaces.list({ limit: 50 });
+console.log(spaces.data.data, spaces.requestId);
+
+const calls = await vuevox.calls.list({ limit: 50 });
+console.log(calls.data.data, calls.requestId);
+
+const leads = await vuevox.leads.list({ limit: 50 });
+console.log(leads.data.data, leads.requestId);
 ```
 
 The SDK requests and caches a short-lived access token using client credentials, then sends it as a bearer token for API calls.
@@ -52,10 +58,10 @@ The SDK requests and caches a short-lived access token using client credentials,
 Every Developer API response includes an `X-Request-Id` header. SDK endpoint methods return response metadata with the response body so you can log that ID for support requests.
 
 ```ts
-const spaces = await vuevox.listSpaces({ limit: 50 });
+const call = await vuevox.calls.get("call-id");
 
-console.log(spaces.requestId);
-console.log(spaces.data.data);
+console.log(call.requestId);
+console.log(call.data.data.transcript);
 ```
 
 For centralized logging, pass `onResponse`. The hook runs for every SDK-managed HTTP response, including the token request.
@@ -64,7 +70,7 @@ For centralized logging, pass `onResponse`. The hook runs for every SDK-managed
 const vuevox = createVueVoxClient({
   clientId: process.env.VUEVOX_CLIENT_ID!,
   clientSecret: process.env.VUEVOX_CLIENT_SECRET!,
-  scope: ["hello:read", "spaces:read"],
+  scope: ["calls:read"],
   onResponse: ({ method, path, status, requestId }) => {
     console.log({ method, path, status, requestId });
   },
@@ -73,7 +79,7 @@ const vuevox = createVueVoxClient({
 
 ## Error Handling
 
-API errors throw `VueVoxApiError`. The SDK exposes `error.requestId` from either the response header or error body.
+API errors throw `VueVoxApiError`. The SDK exposes `error.requestId`, `error.details`, `error.retryAfter`, and `error.isRateLimited`.
 
 ```ts
 import { VueVoxApiError, createVueVoxClient } from "@vuevox/sdk";
@@ -81,11 +87,11 @@ import { VueVoxApiError, createVueVoxClient } from "@vuevox/sdk";
 const vuevox = createVueVoxClient({
   clientId: process.env.VUEVOX_CLIENT_ID!,
   clientSecret: process.env.VUEVOX_CLIENT_SECRET!,
-  scope: ["hello:read", "spaces:read"],
+  scope: ["calls:read"],
 });
 
 try {
-  await vuevox.listSpaces({ limit: 50 });
+  await vuevox.calls.list({ limit: 50 });
 } catch (error) {
   if (error instanceof VueVoxApiError) {
     console.error(error.status, error.code, error.message, error.requestId);
@@ -104,6 +110,49 @@ invalid_client
 invalid_scope
 insufficient_scope
 rate_limited
+invalid_request
+call_not_found
+lead_not_found
+```
+
+## Pagination
+
+List endpoints use cursor pagination.
+
+```ts
+const firstPage = await vuevox.calls.list({ limit: 50 });
+
+if (firstPage.data.pagination.nextCursor) {
+  const secondPage = await vuevox.calls.list({
+    limit: 50,
+    cursor: firstPage.data.pagination.nextCursor,
+  });
+}
+```
+
+The SDK also includes async iterable helpers:
+
+```ts
+for await (const call of vuevox.calls.paginate({ limit: 50 })) {
+  console.log(call.id);
+}
+```
+
+Pagination helpers are available for `spaces`, `calls`, and `leads`.
+
+## Retries
+
+Configure retry/backoff for safe SDK-managed requests. The SDK retries token requests and GET endpoints for `429`, `500`, `502`, `503`, and `504`, and respects `Retry-After` when present.
+
+```ts
+const vuevox = createVueVoxClient({
+  clientId: process.env.VUEVOX_CLIENT_ID!,
+  clientSecret: process.env.VUEVOX_CLIENT_SECRET!,
+  scope: ["calls:read"],
+  retries: 2,
+  retryBaseDelayMs: 250,
+  retryMaxDelayMs: 2000,
+});
 ```
 
 ## Token Behavior
@@ -130,7 +179,7 @@ const vuevox = createVueVoxClient({
   baseUrl: "https://api.vuevox.com",
   clientId: process.env.VUEVOX_CLIENT_ID!,
   clientSecret: process.env.VUEVOX_CLIENT_SECRET!,
-  scope: ["hello:read", "spaces:read"],
+  scope: ["calls:read"],
 });
 ```
 
@@ -145,18 +194,3 @@ const { data, error } = await vuevox.raw.GET("/v1/hello", {
   },
 });
 ```
-
-## Pagination
-
-List endpoints use cursor pagination.
-
-```ts
-const firstPage = await vuevox.listSpaces({ limit: 50 });
-
-if (firstPage.data.pagination.nextCursor) {
-  const secondPage = await vuevox.listSpaces({
-    limit: 50,
-    cursor: firstPage.data.pagination.nextCursor,
-  });
-}
-```

package/dist/client.d.ts

@@ -1,10 +1,29 @@
 import type { components, paths } from "./generated/schema.js";
 type HelloResponse = components["schemas"]["HelloResponse"];
 type SpacesListResponse = components["schemas"]["SpacesListResponse"];
+type CallsListResponse = components["schemas"]["CallsListResponse"];
+type CallDetailResponse = components["schemas"]["CallDetailResponse"];
+type LeadsListResponse = components["schemas"]["LeadsListResponse"];
+type LeadDetailResponse = components["schemas"]["LeadDetailResponse"];
+type Space = components["schemas"]["Space"];
+type CallSummary = components["schemas"]["CallSummary"];
+type Lead = components["schemas"]["Lead"];
 export interface ListSpacesOptions {
     limit?: number;
     cursor?: string;
 }
+export interface ListCallsOptions extends ListSpacesOptions {
+    spaceId?: string;
+    leadId?: string;
+    agentId?: string;
+    createdAfter?: string;
+    createdBefore?: string;
+}
+export interface ListLeadsOptions extends ListSpacesOptions {
+    spaceId?: string;
+    createdAfter?: string;
+    createdBefore?: string;
+}
 export interface VueVoxResponseMetadata {
     requestId?: string;
     status: number;
@@ -15,6 +34,7 @@ export interface VueVoxApiResponse<T> extends VueVoxResponseMetadata {
 export interface VueVoxResponseEvent extends VueVoxResponseMetadata {
     method: string;
     path: string;
+    retryAfter?: number;
 }
 export interface VueVoxClientOptions {
     baseUrl?: string;
@@ -23,11 +43,56 @@ export interface VueVoxClientOptions {
     scope?: string | string[];
     fetch?: typeof fetch;
     onResponse?: (event: VueVoxResponseEvent) => void;
+    retries?: number;
+    retryBaseDelayMs?: number;
+    retryMaxDelayMs?: number;
 }
 export declare function createVueVoxClient(options: VueVoxClientOptions): {
     getAccessToken: () => Promise<string>;
-    hello: () => Promise<VueVoxApiResponse<HelloResponse>>;
-    listSpaces: (listOptions?: ListSpacesOptions) => Promise<VueVoxApiResponse<SpacesListResponse>>;
+    hello: {
+        get: () => Promise<VueVoxApiResponse<HelloResponse>>;
+    };
+    spaces: {
+        list: (listOptions?: ListSpacesOptions) => Promise<VueVoxApiResponse<SpacesListResponse>>;
+        paginate: (listOptions?: ListSpacesOptions) => AsyncGenerator<{
+            id: string;
+            name: string;
+            description: string | null;
+            createdAt: string;
+            updatedAt: string;
+        }, any, any>;
+    };
+    calls: {
+        list: (listOptions?: ListCallsOptions) => Promise<VueVoxApiResponse<CallsListResponse>>;
+        get: (callId: string) => Promise<VueVoxApiResponse<CallDetailResponse>>;
+        paginate: (listOptions?: ListCallsOptions) => AsyncGenerator<{
+            id: string;
+            space: components["schemas"]["ResourceSummary"];
+            lead: components["schemas"]["LeadSummary"];
+            agent: components["schemas"]["ResourceSummary"];
+            duration: number;
+            score: number | null;
+            sentiment: string | null;
+            analysisStatus: string;
+            queueStatus: string | null;
+            createdAt: string;
+            updatedAt: string;
+        }, any, any>;
+    };
+    leads: {
+        list: (listOptions?: ListLeadsOptions) => Promise<VueVoxApiResponse<LeadsListResponse>>;
+        get: (leadId: string) => Promise<VueVoxApiResponse<LeadDetailResponse>>;
+        paginate: (listOptions?: ListLeadsOptions) => AsyncGenerator<{
+            id: string;
+            firstName: string;
+            lastName: string;
+            email: string | null;
+            phone: string | null;
+            space: components["schemas"]["ResourceSummary"];
+            createdAt: string;
+            updatedAt: string;
+        }, any, any>;
+    };
     raw: import("openapi-fetch").Client<paths, `${string}/${string}`>;
 };
-export {};
+export type { CallDetailResponse, CallsListResponse, CallSummary, HelloResponse, Lead, LeadDetailResponse, LeadsListResponse, Space, SpacesListResponse };

package/dist/client.js

@@ -4,12 +4,15 @@ export function createVueVoxClient(options) {
     const baseUrl = trimTrailingSlash(options.baseUrl ?? "https://api.vuevox.com");
     const fetchFn = options.fetch ?? fetch;
     const raw = createClient({ baseUrl, fetch: fetchFn });
+    const retries = options.retries ?? 0;
+    const retryBaseDelayMs = options.retryBaseDelayMs ?? 250;
+    const retryMaxDelayMs = options.retryMaxDelayMs ?? 2_000;
     let cachedToken = null;
     async function getAccessToken() {
         if (cachedToken && Date.now() < cachedToken.expiresAt - 30_000) {
             return cachedToken.accessToken;
         }
-        const response = await fetchFn(`${baseUrl}/oauth/token`, {
+        const result = await requestJson("POST", "/oauth/token", {
             method: "POST",
             headers: {
                 "Content-Type": "application/json",
@@ -21,57 +24,88 @@ export function createVueVoxClient(options) {
                 scope: formatScope(options.scope),
             }),
         });
-        const body = await parseJson(response);
-        const requestId = getRequestId(response, body);
-        notifyResponse(options, "POST", "/oauth/token", response, requestId);
-        if (!response.ok) {
-            const error = isErrorResponse(body) ? body.error : null;
-            throw new VueVoxApiError(response.status, error?.code ?? "token_request_failed", error?.message ?? "VueVox token request failed.", isErrorResponse(body) ? body : undefined, requestId);
-        }
-        if (!isTokenResponse(body)) {
-            throw new VueVoxApiError(response.status, "invalid_token_response", "VueVox returned an invalid token response.", undefined, requestId);
-        }
+        const body = result.data;
         cachedToken = {
             accessToken: body.access_token,
             expiresAt: Date.now() + body.expires_in * 1000,
         };
         return cachedToken.accessToken;
     }
-    async function hello() {
-        const accessToken = await getAccessToken();
-        const { data, error, response } = await raw.GET("/v1/hello", {
-            headers: {
-                Authorization: `Bearer ${accessToken}`,
-            },
-        });
-        const requestId = getRequestId(response, error);
-        notifyResponse(options, "GET", "/v1/hello", response, requestId);
-        if (error) {
-            throw new VueVoxApiError(response.status, error.error.code, error.error.message, error, requestId);
-        }
-        return withMetadata(data, response, requestId);
+    async function getHello() {
+        return apiGet("/v1/hello");
     }
     async function listSpaces(listOptions = {}) {
+        return apiGet("/v1/spaces", listOptions);
+    }
+    async function listCalls(listOptions = {}) {
+        return apiGet("/v1/calls", listOptions);
+    }
+    async function getCall(callId) {
+        return apiGet(`/v1/calls/${encodeURIComponent(callId)}`);
+    }
+    async function listLeads(listOptions = {}) {
+        return apiGet("/v1/leads", listOptions);
+    }
+    async function getLead(leadId) {
+        return apiGet(`/v1/leads/${encodeURIComponent(leadId)}`);
+    }
+    async function apiGet(path, query) {
         const accessToken = await getAccessToken();
-        const { data, error, response } = await raw.GET("/v1/spaces", {
-            params: {
-                query: listOptions,
-            },
+        const result = await requestJson("GET", path, {
+            method: "GET",
             headers: {
                 Authorization: `Bearer ${accessToken}`,
             },
+            query,
         });
-        const requestId = getRequestId(response, error);
-        notifyResponse(options, "GET", "/v1/spaces", response, requestId);
-        if (error) {
-            throw new VueVoxApiError(response.status, error.error.code, error.error.message, error, requestId);
+        return withMetadata(result.data, result.response, result.requestId);
+    }
+    async function requestJson(method, path, init) {
+        for (let attempt = 0;; attempt++) {
+            const response = await fetchFn(buildUrl(baseUrl, path, init.query), init);
+            const body = await parseJson(response);
+            const requestId = getRequestId(response, body);
+            const retryAfter = retryAfterSeconds(response);
+            notifyResponse(options, method, path, response, requestId, retryAfter);
+            if (response.ok) {
+                if (body === null || isErrorResponse(body)) {
+                    throw new VueVoxApiError(response.status, "invalid_response", "VueVox returned an invalid response.", undefined, requestId, retryAfter);
+                }
+                return { data: body, requestId, response };
+            }
+            if (attempt < retries && shouldRetry(response.status)) {
+                await sleep(retryDelayMs(attempt, retryAfter));
+                continue;
+            }
+            const error = isErrorResponse(body) ? body.error : null;
+            throw new VueVoxApiError(response.status, error?.code ?? "api_request_failed", error?.message ?? "VueVox API request failed.", isErrorResponse(body) ? body : undefined, requestId, retryAfter);
+        }
+    }
+    function retryDelayMs(attempt, retryAfter) {
+        if (retryAfter !== undefined) {
+            return retryAfter * 1000;
         }
-        return withMetadata(data, response, requestId);
+        return Math.min(retryBaseDelayMs * 2 ** attempt, retryMaxDelayMs);
     }
     return {
         getAccessToken,
-        hello,
-        listSpaces,
+        hello: {
+            get: getHello,
+        },
+        spaces: {
+            list: listSpaces,
+            paginate: (listOptions = {}) => paginate(listSpaces, listOptions),
+        },
+        calls: {
+            list: listCalls,
+            get: getCall,
+            paginate: (listOptions = {}) => paginate(listCalls, listOptions),
+        },
+        leads: {
+            list: listLeads,
+            get: getLead,
+            paginate: (listOptions = {}) => paginate(listLeads, listOptions),
+        },
         raw,
     };
 }
@@ -84,6 +118,15 @@ function formatScope(scope) {
 function trimTrailingSlash(value) {
     return value.replace(/\/+$/, "");
 }
+function buildUrl(baseUrl, path, query) {
+    const url = new URL(`${baseUrl}${path}`);
+    for (const [key, value] of Object.entries(query ?? {})) {
+        if ((typeof value === "string" || typeof value === "number") && value !== "") {
+            url.searchParams.set(key, String(value));
+        }
+    }
+    return url.toString();
+}
 async function parseJson(response) {
     try {
         return (await response.json());
@@ -93,16 +136,19 @@ async function parseJson(response) {
     }
 }
 function isTokenResponse(value) {
-    return Boolean(value && "access_token" in value);
+    return isObject(value) && "access_token" in value;
 }
 function isErrorResponse(value) {
-    return Boolean(value && "error" in value);
+    return isObject(value) && "error" in value;
 }
 function getRequestId(response, body) {
     return response.headers.get("X-Request-Id") ?? (isErrorBody(body) ? body.error.requestId : undefined);
 }
 function isErrorBody(value) {
-    return Boolean(value && "error" in value);
+    return isObject(value) && "error" in value;
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null;
 }
 function withMetadata(data, response, requestId) {
     return {
@@ -111,11 +157,40 @@ function withMetadata(data, response, requestId) {
         status: response.status,
     };
 }
-function notifyResponse(options, method, path, response, requestId) {
+function notifyResponse(options, method, path, response, requestId, retryAfter) {
     options.onResponse?.({
         method,
         path,
         requestId,
+        retryAfter,
         status: response.status,
     });
 }
+async function* paginate(list, listOptions) {
+    let cursor = listOptions.cursor;
+    do {
+        const response = await list({ ...listOptions, cursor });
+        for (const item of response.data.data) {
+            yield item;
+        }
+        cursor = response.data.pagination.nextCursor ?? undefined;
+    } while (cursor);
+}
+function shouldRetry(status) {
+    return [429, 500, 502, 503, 504].includes(status);
+}
+function retryAfterSeconds(response) {
+    const value = response.headers.get("Retry-After");
+    if (!value) {
+        return undefined;
+    }
+    const seconds = Number(value);
+    if (Number.isFinite(seconds)) {
+        return Math.max(0, seconds);
+    }
+    const timestamp = Date.parse(value);
+    return Number.isNaN(timestamp) ? undefined : Math.max(0, Math.ceil((timestamp - Date.now()) / 1000));
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/errors.d.ts

@@ -3,7 +3,10 @@ export type VueVoxErrorResponse = components["schemas"]["ErrorResponse"];
 export declare class VueVoxApiError extends Error {
     readonly status: number;
     readonly code: string;
+    readonly details?: Record<string, unknown>;
+    readonly isRateLimited: boolean;
     readonly requestId?: string;
+    readonly retryAfter?: number;
     readonly response?: VueVoxErrorResponse;
-    constructor(status: number, code: string, message: string, response?: VueVoxErrorResponse, requestId?: string);
+    constructor(status: number, code: string, message: string, response?: VueVoxErrorResponse, requestId?: string, retryAfter?: number);
 }

package/dist/errors.js

@@ -1,14 +1,20 @@
 export class VueVoxApiError extends Error {
     status;
     code;
+    details;
+    isRateLimited;
     requestId;
+    retryAfter;
     response;
-    constructor(status, code, message, response, requestId) {
+    constructor(status, code, message, response, requestId, retryAfter) {
         super(message);
         this.name = "VueVoxApiError";
         this.status = status;
         this.code = code;
+        this.details = response?.error.details;
+        this.isRateLimited = status === 429 || code === "rate_limited";
         this.requestId = requestId ?? response?.error.requestId;
+        this.retryAfter = retryAfter;
         this.response = response;
     }
 }

package/dist/generated/schema.d.ts

@@ -64,6 +64,86 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/calls": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List organization calls
+         * @description Returns calls for the API client's organization using cursor pagination. List responses do not expose audio storage paths or transcripts.
+         */
+        get: operations["listCalls"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/calls/{callId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get a call
+         * @description Returns a single organization-scoped call with transcript and analysis details.
+         */
+        get: operations["getCall"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/leads": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List organization leads
+         * @description Returns leads for the API client's organization using cursor pagination. The leads:read scope includes email and phone contact details.
+         */
+        get: operations["listLeads"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/leads/{leadId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get a lead
+         * @description Returns a single organization-scoped lead with contact details.
+         */
+        get: operations["getLead"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
 }
 export type webhooks = Record<string, never>;
 export interface components {
@@ -75,7 +155,7 @@ export interface components {
             client_secret: string;
             /**
              * @description Space-separated scopes requested for the access token.
-             * @example hello:read
+             * @example hello:read spaces:read calls:read leads:read
              */
             scope?: string;
         };
@@ -85,7 +165,7 @@ export interface components {
             token_type: "Bearer";
             /** @example 3600 */
             expires_in: number;
-            /** @example hello:read */
+            /** @example hello:read spaces:read calls:read leads:read */
             scope: string;
         };
         HelloResponse: {
@@ -108,6 +188,81 @@ export interface components {
             data: components["schemas"]["Space"][];
             pagination: components["schemas"]["CursorPagination"];
         };
+        ResourceSummary: {
+            /** Format: uuid */
+            id: string;
+            name: string;
+        } | null;
+        LeadSummary: {
+            /** Format: uuid */
+            id: string;
+            firstName: string;
+            lastName: string;
+        } | null;
+        CallSummary: {
+            /** Format: uuid */
+            id: string;
+            space: components["schemas"]["ResourceSummary"];
+            lead: components["schemas"]["LeadSummary"];
+            agent: components["schemas"]["ResourceSummary"];
+            /** @description Call duration in seconds. */
+            duration: number;
+            score: number | null;
+            sentiment: string | null;
+            /** @example completed */
+            analysisStatus: string;
+            /** @example processing */
+            queueStatus: string | null;
+            /** Format: date-time */
+            createdAt: string;
+            /** Format: date-time */
+            updatedAt: string;
+        };
+        CallDetail: components["schemas"]["CallSummary"] & {
+            transcript: {
+                [key: string]: unknown;
+            }[] | null;
+            analysis: components["schemas"]["CallAnalysis"];
+        };
+        CallAnalysis: {
+            summary: string | null;
+            totalScore: number;
+            totalMax: number;
+            sentiment: string;
+            objectiveMet: boolean;
+            objectiveNotes: string | null;
+            detectedTags: string[] | null;
+            strengths: string[] | null;
+            weaknesses: string[] | null;
+        } | null;
+        CallsListResponse: {
+            data: components["schemas"]["CallSummary"][];
+            pagination: components["schemas"]["CursorPagination"];
+        };
+        CallDetailResponse: {
+            data: components["schemas"]["CallDetail"];
+        };
+        Lead: {
+            /** Format: uuid */
+            id: string;
+            firstName: string;
+            lastName: string;
+            /** Format: email */
+            email: string | null;
+            phone: string | null;
+            space: components["schemas"]["ResourceSummary"];
+            /** Format: date-time */
+            createdAt: string;
+            /** Format: date-time */
+            updatedAt: string;
+        };
+        LeadsListResponse: {
+            data: components["schemas"]["Lead"][];
+            pagination: components["schemas"]["CursorPagination"];
+        };
+        LeadDetailResponse: {
+            data: components["schemas"]["Lead"];
+        };
         CursorPagination: {
             /** @example 50 */
             limit: number;
@@ -306,4 +461,276 @@ export interface operations {
             };
         };
     };
+    listCalls: {
+        parameters: {
+            query?: {
+                /** @description Number of calls to return. Defaults to 50. Maximum is 100. */
+                limit?: number;
+                /** @description Opaque cursor from the previous response's pagination.nextCursor value. */
+                cursor?: string;
+                /** @description Filter calls to a space ID. */
+                spaceId?: string;
+                /** @description Filter calls to a lead ID. */
+                leadId?: string;
+                /** @description Filter calls to an agent ID. */
+                agentId?: string;
+                /** @description Return calls created at or after this timestamp. */
+                createdAfter?: string;
+                /** @description Return calls created at or before this timestamp. */
+                createdBefore?: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Paginated calls response. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CallsListResponse"];
+                };
+            };
+            /** @description Bearer token is missing, invalid, or expired. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Bearer token does not include the required scope. */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Query parameters failed validation. */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Per-client rate limit exceeded. */
+            429: {
+                headers: {
+                    /** @description Seconds to wait before retrying. */
+                    "Retry-After"?: string;
+                    /** @description Request limit per minute for this API client. */
+                    "X-RateLimit-Limit"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    getCall: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Call ID. */
+                callId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Call detail response. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CallDetailResponse"];
+                };
+            };
+            /** @description Bearer token is missing, invalid, or expired. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Bearer token does not include the required scope. */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Call was not found in the API client's organization. */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Per-client rate limit exceeded. */
+            429: {
+                headers: {
+                    /** @description Seconds to wait before retrying. */
+                    "Retry-After"?: string;
+                    /** @description Request limit per minute for this API client. */
+                    "X-RateLimit-Limit"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    listLeads: {
+        parameters: {
+            query?: {
+                /** @description Number of leads to return. Defaults to 50. Maximum is 100. */
+                limit?: number;
+                /** @description Opaque cursor from the previous response's pagination.nextCursor value. */
+                cursor?: string;
+                /** @description Filter leads to a space ID. */
+                spaceId?: string;
+                /** @description Return leads created at or after this timestamp. */
+                createdAfter?: string;
+                /** @description Return leads created at or before this timestamp. */
+                createdBefore?: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Paginated leads response. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LeadsListResponse"];
+                };
+            };
+            /** @description Bearer token is missing, invalid, or expired. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Bearer token does not include the required scope. */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Query parameters failed validation. */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Per-client rate limit exceeded. */
+            429: {
+                headers: {
+                    /** @description Seconds to wait before retrying. */
+                    "Retry-After"?: string;
+                    /** @description Request limit per minute for this API client. */
+                    "X-RateLimit-Limit"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    getLead: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Lead ID. */
+                leadId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Lead detail response. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LeadDetailResponse"];
+                };
+            };
+            /** @description Bearer token is missing, invalid, or expired. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Bearer token does not include the required scope. */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Lead was not found in the API client's organization. */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Per-client rate limit exceeded. */
+            429: {
+                headers: {
+                    /** @description Seconds to wait before retrying. */
+                    "Retry-After"?: string;
+                    /** @description Request limit per minute for this API client. */
+                    "X-RateLimit-Limit"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
 }

package/dist/index.d.ts

@@ -1,4 +1,4 @@
 export { createVueVoxClient } from "./client.js";
-export type { ListSpacesOptions, VueVoxApiResponse, VueVoxClientOptions, VueVoxResponseEvent, VueVoxResponseMetadata, } from "./client.js";
+export type { CallDetailResponse, CallsListResponse, CallSummary, HelloResponse, Lead, LeadDetailResponse, LeadsListResponse, ListCallsOptions, ListLeadsOptions, ListSpacesOptions, Space, SpacesListResponse, VueVoxApiResponse, VueVoxClientOptions, VueVoxResponseEvent, VueVoxResponseMetadata, } from "./client.js";
 export { VueVoxApiError } from "./errors.js";
 export type { VueVoxErrorResponse } from "./errors.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vuevox/sdk",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "TypeScript SDK for the VueVox Developer API.",
   "type": "module",
   "main": "./dist/index.js",