@voiflow/sdk 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 VoiFlow
+
+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,83 @@
-# Temporary Holding Version
+# VoiFlow for TypeScript / Node
 
-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.
+Run your voice agents from your own backend: create businesses, set up agents, start calls, read transcripts and get webhooks.
+
+```bash
+npm install @voiflow/sdk
+```
+
+Node 18 or newer. Works with `import` (ESM) and `require` (CommonJS). TypeScript types are included. No other dependencies.
+
+## Quickstart
+
+```ts
+import { VoiFlowClient } from "@voiflow/sdk";
+
+const client = new VoiFlowClient({ apiKey: process.env.VOIFLOW_API_KEY! });
+
+for await (const business of client.businesses.list()) console.log(business.id, business.name);
+
+const call = await client.calls.create(
+  { agent_id: "agent_id", contact_id: "contact_id", mission: "Confirm tomorrow's visit" },
+  { businessId: "business_id" }, // only needed if your key covers more than one business
+);
+console.log(call.call_id, call.status); // "starting": the call is accepted, not yet connected
+```
+
+## Keys
+
+Create keys in the Partner Portal under Developers. A `vf_test_` key works on test data and never places a real call or touches a live business. A `vf_live_` key acts on real businesses and real customers. Both are secret: keep them on your server. The client refuses to start in a browser; give browsers a short-lived token from `client.sessions.create` instead.
+
+A key is either tied to one business or can manage all of yours. With a management key, pass `businessId` on each call (or create the business first with `businesses.create`).
+
+## Lists
+
+List methods return an async iterator and fetch the next page for you.
+
+```ts
+for await (const call of client.calls.list({ days: "7" })) console.log(call.call_id);
+```
+
+## Errors and retries
+
+Failures throw `VoiFlowError` with `status`, `code`, `message`, `requestId` and `details`. A network failure or an HTTP 202 means the result is not known yet (`VoiFlowConnectionError`, `VoiFlowOperationPending`): do not start the action again under a new key. Every method that changes something takes `idempotencyKey`; if you leave it out, one is generated and reused on automatic retries, and it is on the error as `err.idempotencyKey` so you can retry the same action safely.
+
+## Webhooks
+
+Create an endpoint with `client.webhookEndpoints.create({ url, event_types })`. The secret is shown once. Events today: `call.started`, `call.completed`, `agent.published`. Check every delivery before you trust it, using the raw body bytes:
+
+```ts
+import { verifyWebhookSignature, parseWebhookEvent } from "@voiflow/sdk";
+
+verifyWebhookSignature(rawBody, req.headers["voiflow-signature"], secret); // throws if wrong or older than 5 minutes
+const event = parseWebhookEvent(rawBody); // event.id stays the same on retries: use it to skip duplicates
+```
+
+## Before you place calls
+
+Phone calls and browser voice sessions work once VoiFlow has connected a phone line to the business, which VoiFlow does for you during onboarding. Until then `calls.create` and `sessions.create` return a clear error saying so. Webhook endpoints must be public `https` addresses.
+
+## What is in the client
+
+| Group | Methods |
+|---|---|
+| `businesses` | list, create, retrieve, update, readiness, settings, updateSettings |
+| `agents` | list, create, retrieve, update, delete, publish, voiceOptions |
+| `journeys` | list, create, retrieve, update, draft, saveDraft, createVersion, retrieveVersion, publish, impact |
+| `calls` | list, create, retrieve, end, steer, transcript, recording, stream |
+| `conversations` | list, create, retrieve, listMessages, sendMessage, takeover, resumeAi |
+| `contacts` | list, create, retrieve, update, setDnc |
+| `enquiries` | list, retrieve |
+| `appointments`, `calendar` | appointments.list / create; calendar.availability / resources |
+| `knowledge`, `files` | knowledge.list / create / update / publish; files.list / upload / retrieve / download |
+| `projects`, `campaigns`, `runs` | projects.list / create; campaigns.list / create / retrieve / update / setStatus / stats; runs.create / retrieve / stats |
+| `connections`, `integrations`, `channelAccounts`, `lines` | connections.list / create / retrieve / update / readiness; integrations.list; channelAccounts.list / create; lines.list / update |
+| `aiWork` | list, retrieve, cancel, requeue |
+| `webhookEndpoints`, `events` | webhookEndpoints.list / create / retrieve / update / delete / rotateSecret / listDeliveries; events.list / replay |
+| `sessions`, `usage`, `limits`, `operations` | sessions.create; usage.get / costs; limits.get; operations.retrieve |
+
+Upload a document: `await client.files.upload(bytes, { filename: "policy.pdf", contentType: "application/pdf" })`.
+
+Field names are the same as in the API reference (`agent_id`, `contact_id`).
+
+MIT licence.

package/dist/cjs/client.js

@@ -0,0 +1,43 @@
+"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.SIGNATURE_HEADER = exports.WebhookSignatureError = exports.parseWebhookEvent = exports.verifyWebhookSignature = exports.VoiFlowOperationPending = exports.VoiFlowConnectionError = exports.VoiFlowError = exports.HttpClient = exports.VoiFlowClient = void 0;
+const http_js_1 = require("./http.js");
+Object.defineProperty(exports, "HttpClient", { enumerable: true, get: function () { return http_js_1.HttpClient; } });
+const resources_generated_js_1 = require("./resources.generated.js");
+/** Server-side client. Every published /v1 resource group is a property (`client.agents`, `client.aiWork`, ...). */
+class VoiFlowClient extends resources_generated_js_1.GeneratedResources {
+    transport;
+    constructor(options) {
+        const http = new http_js_1.HttpClient(options);
+        super(http);
+        this.transport = http;
+    }
+    get environment() {
+        return this.transport.environment;
+    }
+}
+exports.VoiFlowClient = VoiFlowClient;
+__exportStar(require("./resources.generated.js"), exports);
+var errors_js_1 = require("./errors.js");
+Object.defineProperty(exports, "VoiFlowError", { enumerable: true, get: function () { return errors_js_1.VoiFlowError; } });
+Object.defineProperty(exports, "VoiFlowConnectionError", { enumerable: true, get: function () { return errors_js_1.VoiFlowConnectionError; } });
+Object.defineProperty(exports, "VoiFlowOperationPending", { enumerable: true, get: function () { return errors_js_1.VoiFlowOperationPending; } });
+var webhooks_js_1 = require("./webhooks.js");
+Object.defineProperty(exports, "verifyWebhookSignature", { enumerable: true, get: function () { return webhooks_js_1.verifyWebhookSignature; } });
+Object.defineProperty(exports, "parseWebhookEvent", { enumerable: true, get: function () { return webhooks_js_1.parseWebhookEvent; } });
+Object.defineProperty(exports, "WebhookSignatureError", { enumerable: true, get: function () { return webhooks_js_1.WebhookSignatureError; } });
+Object.defineProperty(exports, "SIGNATURE_HEADER", { enumerable: true, get: function () { return webhooks_js_1.SIGNATURE_HEADER; } });

package/dist/cjs/errors.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VoiFlowOperationPending = exports.VoiFlowConnectionError = exports.VoiFlowError = void 0;
+/** Thrown for any non-2xx API response or a request that could not be sent. */
+class VoiFlowError extends Error {
+    code;
+    status;
+    requestId;
+    details;
+    operationId;
+    statusUrl;
+    /** The Idempotency-Key the failed call used; pass it back to retry the same logical operation. */
+    idempotencyKey;
+    constructor(status, body) {
+        super(body.message);
+        this.name = "VoiFlowError";
+        this.status = status;
+        this.code = body.code;
+        this.requestId = body.request_id;
+        this.details = body.details;
+        this.operationId = body.operation_id;
+        this.statusUrl = body.status_url;
+    }
+}
+exports.VoiFlowError = VoiFlowError;
+/** The request never reached the server or the response could not be parsed (unknown outcome). */
+class VoiFlowConnectionError extends Error {
+    cause;
+    /** The Idempotency-Key the call used; pass it back to retry without repeating the action. */
+    idempotencyKey;
+    constructor(message, cause) {
+        super(message);
+        this.name = "VoiFlowConnectionError";
+        this.cause = cause;
+    }
+}
+exports.VoiFlowConnectionError = VoiFlowConnectionError;
+/**
+ * HTTP 202: the server accepted the request but its outcome is not yet known. The action may still
+ * complete, so do not repeat it under a new Idempotency-Key — poll `operations.retrieve(operationId)`
+ * or retry with the same `idempotencyKey`.
+ */
+class VoiFlowOperationPending extends VoiFlowError {
+    constructor(body) {
+        super(202, body);
+        this.name = "VoiFlowOperationPending";
+    }
+}
+exports.VoiFlowOperationPending = VoiFlowOperationPending;

package/dist/cjs/http.js

@@ -0,0 +1,280 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpClient = void 0;
+const node_crypto_1 = require("node:crypto");
+const errors_js_1 = require("./errors.js");
+const DEFAULT_BASE_URL = "https://api.voiflow.ai/v1";
+const RETRYABLE_STATUS = new Set([429, 500, 502, 503, 504]);
+const REQUEST_ID_HEADER = "VoiFlow-Request-Id";
+function isKeyValid(key) {
+    return key.startsWith("vf_live_") || key.startsWith("vf_test_");
+}
+function assertServerRuntime() {
+    // This SDK holds a secret vf_live_/vf_test_ key. A browser runtime (window + document) means
+    // the key would ship to every visitor; refuse to construct the client at all in that case.
+    const g = globalThis;
+    if (typeof g.window !== "undefined" && typeof g.document !== "undefined") {
+        throw new Error("The VoiFlow SDK holds a secret server credential and must not run in a browser. " +
+            "Use it from your backend and give the browser a short-lived session token instead.");
+    }
+}
+class HttpClient {
+    apiKey;
+    baseUrl;
+    timeoutMs;
+    maxRetries;
+    fetchImpl;
+    constructor(options) {
+        assertServerRuntime();
+        if (!isKeyValid(options.apiKey)) {
+            throw new Error("apiKey must start with vf_live_ or vf_test_; browser/public keys are not supported here.");
+        }
+        this.apiKey = options.apiKey;
+        this.baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+        this.timeoutMs = options.timeoutMs ?? 30_000;
+        this.maxRetries = options.maxRetries ?? 2;
+        this.fetchImpl = options.fetch ?? fetch;
+    }
+    get environment() {
+        return this.apiKey.startsWith("vf_live_") ? "live" : "test";
+    }
+    resolvedUrl(path, query) {
+        const url = new URL(this.baseUrl + path);
+        if (query) {
+            for (const [key, value] of Object.entries(query)) {
+                if (value !== undefined)
+                    url.searchParams.set(key, String(value));
+            }
+        }
+        return url;
+    }
+    /** Opens an authenticated text/event-stream GET request and returns its raw body. */
+    async openStream(path, query, options = {}) {
+        const url = this.resolvedUrl(path, query);
+        const headers = {
+            Authorization: `Bearer ${this.apiKey}`,
+            Accept: "text/event-stream",
+        };
+        if (options.lastEventId)
+            headers["Last-Event-ID"] = options.lastEventId;
+        const response = await this.fetchImpl(url, { headers, signal: options.signal });
+        if (!response.ok || !response.body) {
+            const body = await parseErrorBody(response);
+            throw new errors_js_1.VoiFlowError(response.status, body);
+        }
+        return response.body;
+    }
+    /** A successful binary response (e.g. a recording or document download) is raw bytes with an
+     * arbitrary content-type, not the {data, request_id} JSON envelope — an error response still is. */
+    async requestBinary(method, path, options = {}) {
+        const url = this.resolvedUrl(path, options.query);
+        const headers = { Authorization: `Bearer ${this.apiKey}` };
+        const response = await this.runWithRetry(method, url, headers, undefined, options);
+        const requestId = readRequestId(response, undefined);
+        if (!response.ok) {
+            throw new errors_js_1.VoiFlowError(response.status, await parseErrorBody(response));
+        }
+        const data = new Uint8Array(await response.arrayBuffer());
+        return { data, contentType: response.headers.get("content-type") ?? "application/octet-stream", requestId, status: response.status };
+    }
+    /** Uploads raw bytes with an explicit content-type instead of JSON-serialising an object —
+     * the gateway forwards the body/content-type verbatim for upload routes. */
+    async uploadBinary(method, path, content, contentType, options = {}) {
+        const url = this.resolvedUrl(path, options.query);
+        const headers = { Authorization: `Bearer ${this.apiKey}`, "Content-Type": contentType, Accept: "application/json" };
+        if (options.idempotencyKey)
+            headers["Idempotency-Key"] = options.idempotencyKey;
+        const response = await this.runWithRetry(method, url, headers, content, { idempotencyKey: options.idempotencyKey, signal: options.signal });
+        return this.parseJsonResponse(response);
+    }
+    /** Multipart/form-data upload (a document plus optional JSON `metadata`). Idempotent: a stable key is generated once per call. */
+    async uploadMultipart(method, path, file, options = {}) {
+        const idempotencyKey = options.idempotencyKey ?? (0, node_crypto_1.randomUUID)();
+        const form = new FormData();
+        const blob = file instanceof Blob ? file : new Blob([file], { type: options.contentType ?? "application/octet-stream" });
+        form.append("file", blob, options.filename ?? "upload");
+        if (options.metadata)
+            form.append("metadata", JSON.stringify(options.metadata));
+        const url = this.resolvedUrl(path, { business_id: options.businessId });
+        // No Content-Type here: fetch sets multipart/form-data with the boundary itself.
+        const headers = {
+            Authorization: `Bearer ${this.apiKey}`,
+            Accept: "application/json",
+            "Idempotency-Key": idempotencyKey,
+        };
+        try {
+            const response = await this.runWithRetry(method, url, headers, form, { idempotencyKey });
+            return await this.parseJsonResponse(response);
+        }
+        catch (err) {
+            if (err instanceof errors_js_1.VoiFlowError || err instanceof errors_js_1.VoiFlowConnectionError)
+                err.idempotencyKey = idempotencyKey;
+            throw err;
+        }
+    }
+    async request(method, path, options = {}) {
+        const idempotencyKey = options.idempotencyKey ?? (options.idempotent ? (0, node_crypto_1.randomUUID)() : undefined);
+        const url = this.resolvedUrl(path, options.query);
+        const headers = {
+            Authorization: `Bearer ${this.apiKey}`,
+            Accept: "application/json",
+        };
+        if (idempotencyKey)
+            headers["Idempotency-Key"] = idempotencyKey;
+        let payload;
+        if (options.body !== undefined) {
+            headers["Content-Type"] = "application/json";
+            payload = JSON.stringify(options.body);
+        }
+        try {
+            const response = await this.runWithRetry(method, url, headers, payload, { ...options, idempotencyKey });
+            return await this.parseJsonResponse(response);
+        }
+        catch (err) {
+            if (idempotencyKey && (err instanceof errors_js_1.VoiFlowError || err instanceof errors_js_1.VoiFlowConnectionError)) {
+                err.idempotencyKey = idempotencyKey;
+            }
+            throw err;
+        }
+    }
+    async parseJsonResponse(response) {
+        if (!response.ok) {
+            throw new errors_js_1.VoiFlowError(response.status, await parseErrorBody(response));
+        }
+        if (response.status === 204 || response.headers.get("content-length") === "0") {
+            return { data: undefined, requestId: readRequestId(response, undefined), status: response.status };
+        }
+        const parsed = (await response.json());
+        if (response.status === 202 && parsed.error && !("data" in parsed)) {
+            throw new errors_js_1.VoiFlowOperationPending({ ...parsed.error, request_id: parsed.error.request_id ?? readRequestId(response, undefined) });
+        }
+        const requestId = readRequestId(response, parsed?.request_id);
+        return { data: parsed, requestId, status: response.status };
+    }
+    async runWithRetry(method, url, headers, body, options) {
+        const isSafeRetry = method === "GET" || options.idempotencyKey !== undefined;
+        let attempt = 0;
+        let lastError;
+        while (attempt <= this.maxRetries) {
+            if (options.signal?.aborted) {
+                throw new errors_js_1.VoiFlowConnectionError("Request was cancelled.", options.signal.reason);
+            }
+            const controller = new AbortController();
+            const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+            const cleanupAbortLink = options.signal ? linkSignals(options.signal, controller) : undefined;
+            try {
+                const response = await this.fetchImpl(url, { method, headers, body, signal: controller.signal });
+                clearTimeout(timer);
+                cleanupAbortLink?.();
+                if (RETRYABLE_STATUS.has(response.status) && isSafeRetry && attempt < this.maxRetries) {
+                    const waited = await waitForRetry(retryDelayMs(response, attempt), options.signal);
+                    if (!waited)
+                        throw new errors_js_1.VoiFlowConnectionError("Request was cancelled.", options.signal?.reason);
+                    attempt += 1;
+                    continue;
+                }
+                return response;
+            }
+            catch (err) {
+                clearTimeout(timer);
+                cleanupAbortLink?.();
+                if (err instanceof errors_js_1.VoiFlowError || err instanceof errors_js_1.VoiFlowConnectionError)
+                    throw err;
+                if (options.signal?.aborted) {
+                    throw new errors_js_1.VoiFlowConnectionError("Request was cancelled.", options.signal.reason);
+                }
+                lastError = err;
+                if (isSafeRetry && attempt < this.maxRetries) {
+                    const waited = await waitForRetry(retryDelayMs(undefined, attempt), options.signal);
+                    if (!waited)
+                        throw new errors_js_1.VoiFlowConnectionError("Request was cancelled.", options.signal?.reason);
+                    attempt += 1;
+                    continue;
+                }
+                throw new errors_js_1.VoiFlowConnectionError("VoiFlow API request failed; outcome is unknown.", err);
+            }
+        }
+        throw new errors_js_1.VoiFlowConnectionError("VoiFlow API request exhausted retries.", lastError);
+    }
+}
+exports.HttpClient = HttpClient;
+function readRequestId(response, fromBody) {
+    // VoiFlow-Request-Id is a real response header on every /v1 response (success and error
+    // alike) — the only reliable source for binary/204 responses, which carry no JSON body.
+    return fromBody ?? response.headers.get(REQUEST_ID_HEADER) ?? undefined;
+}
+// The curated contract's error envelope is {error:{code,message,request_id,details?}}, but some
+// routes still raise a plain FastAPI HTTPException ({detail:{code,message}} or {detail:"..."}),
+// and parameter validation failures use FastAPI's own {detail:[{loc,msg,type},...]} shape. All
+// three are observed on the real gateway; handle all three rather than assuming the curated one.
+async function parseErrorBody(response) {
+    const requestId = response.headers.get(REQUEST_ID_HEADER) ?? undefined;
+    try {
+        const json = (await response.json());
+        if (json.error) {
+            return {
+                code: json.error.code,
+                message: json.error.message,
+                request_id: json.error.request_id ?? requestId,
+                details: json.error.details,
+                operation_id: json.error.operation_id,
+                status_url: json.error.status_url,
+            };
+        }
+        if (typeof json.detail === "string") {
+            return { code: "http_error", message: json.detail, request_id: requestId };
+        }
+        if (Array.isArray(json.detail)) {
+            return { code: "unprocessable", message: "the request was not valid", request_id: requestId, details: json.detail };
+        }
+        if (json.detail) {
+            return {
+                code: json.detail.code ?? "http_error",
+                message: json.detail.message ?? `Request failed with status ${response.status}`,
+                request_id: requestId,
+            };
+        }
+    }
+    catch {
+        // body was not JSON; fall through to generic error below
+    }
+    return { code: "unknown_error", message: `Request failed with status ${response.status}`, request_id: requestId };
+}
+function retryDelayMs(response, attempt) {
+    const retryAfter = response?.headers.get("Retry-After");
+    if (retryAfter) {
+        const seconds = Number(retryAfter);
+        if (!Number.isNaN(seconds))
+            return seconds * 1000;
+        const whenMs = Date.parse(retryAfter);
+        if (!Number.isNaN(whenMs))
+            return Math.max(0, whenMs - Date.now());
+    }
+    return 250 * 2 ** attempt;
+}
+/** Resolves true after the delay, or false immediately if the signal aborts first — so a
+ * cancelled request doesn't sit out a retry backoff it will never use. */
+function waitForRetry(ms, signal) {
+    return new Promise((resolve) => {
+        if (signal?.aborted) {
+            resolve(false);
+            return;
+        }
+        const timer = setTimeout(() => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve(true);
+        }, ms);
+        const onAbort = () => {
+            clearTimeout(timer);
+            resolve(false);
+        };
+        signal?.addEventListener("abort", onAbort, { once: true });
+    });
+}
+/** Aborts `controller` when `signal` aborts, and always removes its own listener afterward —
+ * each attempt gets its own link instead of accumulating listeners across retries. */
+function linkSignals(signal, controller) {
+    const onAbort = () => controller.abort(signal.reason);
+    signal.addEventListener("abort", onAbort, { once: true });
+    return () => signal.removeEventListener("abort", onAbort);
+}

package/dist/cjs/index.js

@@ -0,0 +1,17 @@
+"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 });
+__exportStar(require("./client.js"), exports);

package/dist/cjs/package.json

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

package/dist/cjs/pagination.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginate = paginate;
+/** Lazily walks every page of a cursor-paginated list endpoint. */
+async function* paginate(fetchPage) {
+    let cursor;
+    while (true) {
+        const page = await fetchPage(cursor);
+        for (const item of page.data)
+            yield item;
+        if (!page.next_cursor)
+            return;
+        cursor = page.next_cursor;
+    }
+}