@pagouai/api-sdk 0.1.1

package/README.md

@@ -0,0 +1,211 @@
+# Pagou.ai TypeScript SDK (`/v2`)
+
+Cross-runtime SDK template for Node.js 18+, Bun, and Deno.
+
+- Resource-first API (`client.transactions.*`)
+- `fetch`-based (no axios)
+- Typed errors
+- Retries + timeout + idempotency
+- Native `/v2` page/limit pagination
+
+## Install
+
+```bash
+bun add @pagouai/api-sdk
+# or npm i / pnpm add
+```
+
+## Quick Start
+
+```ts
+import { Client } from "@pagouai/api-sdk";
+
+const client = new Client({
+	apiKey: "YOUR_API_KEY",
+	timeoutMs: 30_000,
+	maxRetries: 2,
+	telemetry: true,
+});
+```
+
+## Configuration
+
+```ts
+new Client({
+	apiKey: "YOUR_API_KEY",
+	environment: "production", // default: "production"
+	// environment: "sandbox",
+	// baseUrl: "https://api.sandbox.pagou.ai", // explicit override if needed
+	timeoutMs: 30_000,
+	maxRetries: 2,
+	telemetry: true,
+	userAgent: "PagouTS-SDK/0.1.0 (Transactions; +https://pagou.ai)",
+	fetch: customFetch,
+	auth: { scheme: "bearer" }, // default
+	// apiVersion: "2026-02-01",
+});
+```
+
+Auth schemes:
+
+- `bearer` (default) -> `Authorization: Bearer <apiKey>`
+- `basic` -> `Authorization: Basic <base64(apiKey:x)>`
+- `api_key_header` -> `apikey: <apiKey>` (or custom `headerName`)
+
+Default base URLs:
+
+- production: `https://api.pagou.ai`
+- sandbox/test: `https://api.sandbox.pagou.ai`
+
+## API Coverage (`/v2`)
+
+- `POST /v2/transactions`
+- `GET /v2/transactions`
+- `GET /v2/transactions/{id}`
+- `PUT /v2/transactions/{id}` (test/sandbox-only behavior)
+- `PUT /v2/transactions/{id}/refund`
+
+## Usage Examples
+
+### 1) Create a transaction
+
+```ts
+const created = await client.transactions.create({
+	amount: 1500,
+	method: "pix",
+	currency: "BRL",
+	buyer: {
+		name: "Jane Doe",
+		email: "jane@example.com",
+	},
+	products: [{ name: "Pro Plan", price: 1500, quantity: 1 }],
+});
+
+console.log(created.data.id, created.meta.requestId);
+```
+
+### 2) Retrieve a transaction
+
+```ts
+const tx = await client.transactions.retrieve("tr_123");
+console.log(tx.data.status);
+```
+
+### 3) List transactions with page/limit + filters
+
+```ts
+const page = await client.transactions.list({
+	page: 1,
+	limit: 20,
+	status: ["pending", "paid"],
+	paymentMethods: ["pix"],
+});
+
+console.log(page.data.metadata.total);
+for (const item of page.data.data) {
+	console.log(item.id, item.status);
+}
+```
+
+### 4) Auto-paging iterator
+
+```ts
+for await (const item of client.transactions.listAutoPagingIterator({ limit: 100 })) {
+	console.log(item.id);
+}
+```
+
+### 5) Refund a transaction
+
+```ts
+const refunded = await client.transactions.refund(
+	"tr_123",
+	{ amount: 500, reason: "requested_by_customer" },
+	{ idempotencyKey: "idem_refund_tr_123_1" },
+);
+
+console.log(refunded.data);
+```
+
+## Request Options
+
+All resource methods accept `opts?`:
+
+```ts
+{
+	idempotencyKey?: string;
+	requestId?: string;
+	timeoutMs?: number;
+	signal?: AbortSignal;
+}
+```
+
+## Retries and Timeout
+
+Retries happen for:
+
+- Network errors
+- `429`, `500`, `502`, `503`, `504`
+
+Rules:
+
+- Always retry for `GET`/`HEAD`
+- Retry `POST`/`PUT` only when `idempotencyKey` is set
+- Respect `Retry-After` header when available
+
+Timeout uses `AbortController`.
+
+## Error Handling
+
+```ts
+import {
+	AuthenticationError,
+	InvalidRequestError,
+	NotFoundError,
+	RateLimitError,
+	ServerError,
+	NetworkError,
+} from "@pagouai/api-sdk";
+
+try {
+	await client.transactions.retrieve("tr_404");
+} catch (error) {
+	if (error instanceof NotFoundError) {
+		console.error("Missing transaction", error.requestId);
+	} else if (error instanceof RateLimitError) {
+		console.error("Back off", error.status, error.code);
+	} else if (error instanceof NetworkError) {
+		console.error("Network issue", error.message);
+	} else if (error instanceof InvalidRequestError || error instanceof AuthenticationError || error instanceof ServerError) {
+		console.error(error.message);
+	} else {
+		throw error;
+	}
+}
+```
+
+## Response Shapes
+
+Data endpoints:
+
+```ts
+{
+	success: boolean;
+	requestId: string;
+	data: T;
+}
+```
+
+List endpoints:
+
+```ts
+{
+	success: boolean;
+	requestId: string;
+	metadata: { page: number; limit: number; total: number };
+	data: T[];
+}
+```
+
+Notes:
+- This SDK uses `/v2` endpoint paths.

package/dist/client.d.ts

@@ -0,0 +1,50 @@
+import { TransactionsResource } from "./resources/transactions";
+import type { ApiResponse, ClientOptions, PaginatedEnvelope, RequestOptions } from "./types";
+type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD";
+interface RawResponse {
+    status: number;
+    headers: Headers;
+    body: unknown;
+    requestId?: string;
+}
+interface RequestInput {
+    method: HttpMethod;
+    path: string;
+    query?: Record<string, unknown>;
+    body?: unknown;
+    options?: RequestOptions;
+}
+/**
+ * Main SDK client for Pagou.ai API.
+ */
+export declare class Client {
+    private readonly apiKey;
+    private readonly baseUrl;
+    private readonly timeoutMs;
+    private readonly maxRetries;
+    private readonly telemetry;
+    private readonly userAgent;
+    private readonly fetchImpl;
+    private readonly auth;
+    private readonly apiVersion?;
+    private readonly retryBaseDelayMs;
+    private readonly maxRetryDelayMs;
+    readonly transactions: TransactionsResource;
+    constructor(options: ClientOptions);
+    /**
+     * Sends a request and unwraps a data envelope.
+     */
+    requestData<T>(input: RequestInput): Promise<ApiResponse<T>>;
+    /**
+     * Sends a request and unwraps a paginated envelope.
+     */
+    requestPaginated<T>(input: RequestInput): Promise<ApiResponse<PaginatedEnvelope<T>>>;
+    requestRaw(input: RequestInput): Promise<RawResponse>;
+    private prepareRequest;
+    private applyAuthHeader;
+    private applyVersionHeader;
+    private applyTelemetryHeaders;
+    private toApiError;
+}
+export {};
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAYA,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAChE,OAAO,KAAK,EACX,WAAW,EAGX,aAAa,EAGb,iBAAiB,EACjB,cAAc,EAEd,MAAM,SAAS,CAAC;AAajB,KAAK,UAAU,GAAG,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,OAAO,GAAG,QAAQ,GAAG,MAAM,CAAC;AAUvE,UAAU,WAAW;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,OAAO,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,UAAU,YAAY;IACrB,MAAM,EAAE,UAAU,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,OAAO,CAAC,EAAE,cAAc,CAAC;CACzB;AAED;;GAEG;AACH,qBAAa,MAAM;IAClB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAU;IACpC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAY;IACtC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAa;IAClC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAS;IAC1C,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAS;IAEzC,SAAgB,YAAY,EAAE,oBAAoB,CAAC;gBAEvC,OAAO,EAAE,aAAa;IAoBlC;;OAEG;IACU,WAAW,CAAC,CAAC,EAAE,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;IAiBzE;;OAEG;IACU,gBAAgB,CAAC,CAAC,EAAE,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,WAAW,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAAC;IAiBpF,UAAU,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,WAAW,CAAC;IAsElE,OAAO,CAAC,cAAc;IA+FtB,OAAO,CAAC,eAAe;IAgBvB,OAAO,CAAC,kBAAkB;IAQ1B,OAAO,CAAC,qBAAqB;IAa7B,OAAO,CAAC,UAAU;CA+BlB"}

package/dist/client.js

@@ -0,0 +1,448 @@
+import { ApiError, AuthenticationError, ConflictError, InvalidRequestError, NetworkError, NotFoundError, PermissionError, parseErrorPayload, RateLimitError, ServerError, } from "./errors";
+import { TransactionsResource } from "./resources/transactions";
+import { SDK_VERSION } from "./version";
+const PRODUCTION_BASE_URL = "https://api.pagou.ai";
+const SANDBOX_BASE_URL = "https://api.sandbox.pagou.ai";
+const DEFAULT_AUTH_SCHEME = "bearer";
+const DEFAULT_AUTH_HEADER_NAME = "apikey";
+const DEFAULT_USER_AGENT = `PagouTS-SDK/${SDK_VERSION} (Transactions; +https://pagou.ai)`;
+const DEFAULT_API_VERSION_HEADER = "{{API_VERSION_HEADER}}";
+const DEFAULT_API_VERSION = "{{API_VERSION}}";
+const RETRY_STATUS_CODES = new Set([429, 500, 502, 503, 504]);
+/**
+ * Main SDK client for Pagou.ai API.
+ */
+export class Client {
+    apiKey;
+    baseUrl;
+    timeoutMs;
+    maxRetries;
+    telemetry;
+    userAgent;
+    fetchImpl;
+    auth;
+    apiVersion;
+    retryBaseDelayMs;
+    maxRetryDelayMs;
+    transactions;
+    constructor(options) {
+        if (!options.apiKey) {
+            throw new Error("Client requires an apiKey.");
+        }
+        this.apiKey = options.apiKey;
+        this.baseUrl = normalizeBaseUrl(options.baseUrl ?? resolveEnvironmentBaseUrl(options.environment));
+        this.timeoutMs = options.timeoutMs ?? 30_000;
+        this.maxRetries = options.maxRetries ?? 2;
+        this.telemetry = options.telemetry ?? true;
+        this.userAgent = options.userAgent ?? DEFAULT_USER_AGENT;
+        this.fetchImpl = resolveFetch(options.fetch);
+        this.auth = options.auth ?? resolveDefaultAuth();
+        this.apiVersion = options.apiVersion ?? resolvePlaceholder(DEFAULT_API_VERSION);
+        this.retryBaseDelayMs = options.retryBaseDelayMs ?? 200;
+        this.maxRetryDelayMs = options.maxRetryDelayMs ?? 2_000;
+        this.transactions = new TransactionsResource(this);
+    }
+    /**
+     * Sends a request and unwraps a data envelope.
+     */
+    async requestData(input) {
+        const raw = await this.requestRaw(input);
+        const envelope = raw.body;
+        if (!isDataEnvelope(envelope)) {
+            throw new ApiError("Unexpected response format: expected data envelope", {
+                status: raw.status,
+                requestId: raw.requestId,
+                raw: raw.body,
+            });
+        }
+        return {
+            data: envelope.data,
+            meta: toMeta(raw),
+        };
+    }
+    /**
+     * Sends a request and unwraps a paginated envelope.
+     */
+    async requestPaginated(input) {
+        const raw = await this.requestRaw(input);
+        const envelope = raw.body;
+        if (!isPaginatedEnvelope(envelope)) {
+            throw new ApiError("Unexpected response format: expected paginated envelope", {
+                status: raw.status,
+                requestId: raw.requestId,
+                raw: raw.body,
+            });
+        }
+        return {
+            data: envelope,
+            meta: toMeta(raw),
+        };
+    }
+    async requestRaw(input) {
+        const method = input.method;
+        const canRetry = isRetryEligible(method, input.options?.idempotencyKey);
+        let attempt = 0;
+        for (;;) {
+            const prepared = this.prepareRequest(input);
+            try {
+                const response = await this.fetchImpl(prepared.url, prepared.init);
+                const requestId = extractRequestId(response.headers);
+                const body = await parseBody(response);
+                if (!response.ok) {
+                    const shouldRetryStatus = RETRY_STATUS_CODES.has(response.status);
+                    const shouldRetry = canRetry && shouldRetryStatus && attempt < this.maxRetries;
+                    if (shouldRetry) {
+                        const delayMs = computeRetryDelayMs(attempt, response.headers.get("Retry-After"), this.retryBaseDelayMs, this.maxRetryDelayMs);
+                        attempt += 1;
+                        prepared.clear();
+                        await sleep(delayMs);
+                        continue;
+                    }
+                    prepared.clear();
+                    throw this.toApiError(response.status, body, requestId);
+                }
+                prepared.clear();
+                return {
+                    status: response.status,
+                    headers: response.headers,
+                    body,
+                    requestId: requestId ?? extractRequestIdFromBody(body),
+                };
+            }
+            catch (error) {
+                prepared.clear();
+                if (error instanceof ApiError) {
+                    throw error;
+                }
+                const aborted = isAbortError(error);
+                const timedOut = prepared.didTimeout();
+                const retryable = !aborted;
+                if (canRetry && retryable && attempt < this.maxRetries) {
+                    const delayMs = computeRetryDelayMs(attempt, undefined, this.retryBaseDelayMs, this.maxRetryDelayMs);
+                    attempt += 1;
+                    await sleep(delayMs);
+                    continue;
+                }
+                const message = timedOut
+                    ? `Request timed out after ${input.options?.timeoutMs ?? this.timeoutMs}ms`
+                    : "Network request failed";
+                throw new NetworkError(message, {
+                    cause: error,
+                });
+            }
+        }
+    }
+    prepareRequest(input) {
+        const headers = new Headers();
+        headers.set("Accept", "application/json");
+        if (input.body !== undefined) {
+            headers.set("Content-Type", "application/json");
+        }
+        const requestId = input.options?.requestId;
+        if (requestId) {
+            headers.set("X-Request-Id", requestId);
+        }
+        if (input.options?.idempotencyKey) {
+            headers.set("Idempotency-Key", input.options.idempotencyKey);
+        }
+        this.applyAuthHeader(headers);
+        this.applyVersionHeader(headers);
+        this.applyTelemetryHeaders(headers);
+        const url = new URL(input.path, this.baseUrl);
+        if (input.query) {
+            for (const [key, value] of Object.entries(input.query)) {
+                if (value === undefined || value === null) {
+                    continue;
+                }
+                if (Array.isArray(value)) {
+                    if (value.length === 0) {
+                        continue;
+                    }
+                    url.searchParams.set(key, value.map((v) => String(v)).join(","));
+                    continue;
+                }
+                url.searchParams.set(key, String(value));
+            }
+        }
+        const controller = new AbortController();
+        const externalSignal = input.options?.signal;
+        const timeoutMs = input.options?.timeoutMs ?? this.timeoutMs;
+        let timedOut = false;
+        let timeoutHandle;
+        const onExternalAbort = () => {
+            if (!controller.signal.aborted) {
+                controller.abort();
+            }
+        };
+        if (externalSignal) {
+            if (externalSignal.aborted) {
+                onExternalAbort();
+            }
+            else {
+                externalSignal.addEventListener("abort", onExternalAbort, { once: true });
+            }
+        }
+        if (timeoutMs > 0) {
+            timeoutHandle = setTimeout(() => {
+                timedOut = true;
+                if (!controller.signal.aborted) {
+                    controller.abort();
+                }
+            }, timeoutMs);
+        }
+        const init = {
+            method: input.method,
+            headers,
+            signal: controller.signal,
+        };
+        if (input.body !== undefined) {
+            init.body = JSON.stringify(input.body);
+        }
+        const clear = () => {
+            if (timeoutHandle !== undefined) {
+                clearTimeout(timeoutHandle);
+            }
+            if (externalSignal) {
+                externalSignal.removeEventListener("abort", onExternalAbort);
+            }
+        };
+        return {
+            url,
+            init,
+            timeoutHandle,
+            clear,
+            didTimeout: () => timedOut,
+        };
+    }
+    applyAuthHeader(headers) {
+        switch (this.auth.scheme) {
+            case "bearer":
+                headers.set("Authorization", `Bearer ${this.apiKey}`);
+                break;
+            case "basic":
+                headers.set("Authorization", `Basic ${encodeBase64(`${this.apiKey}:x`)}`);
+                break;
+            case "api_key_header": {
+                const fallbackHeaderName = resolvePlaceholder(DEFAULT_AUTH_HEADER_NAME) ?? "apikey";
+                headers.set(this.auth.headerName ?? fallbackHeaderName, this.apiKey);
+                break;
+            }
+        }
+    }
+    applyVersionHeader(headers) {
+        const versionHeaderName = resolvePlaceholder(DEFAULT_API_VERSION_HEADER);
+        if (!versionHeaderName || !this.apiVersion) {
+            return;
+        }
+        headers.set(versionHeaderName, this.apiVersion);
+    }
+    applyTelemetryHeaders(headers) {
+        if (!this.telemetry) {
+            return;
+        }
+        if (this.userAgent) {
+            headers.set("User-Agent", this.userAgent);
+        }
+        headers.set("X-SDK-Lang", "typescript");
+        headers.set("X-SDK-Runtime", detectRuntime());
+    }
+    toApiError(status, body, requestIdFromHeader) {
+        const parsed = parseErrorPayload(body, `Request failed with status ${status}`, requestIdFromHeader);
+        const common = {
+            status,
+            code: parsed.code,
+            requestId: parsed.requestId,
+            details: parsed.details,
+            raw: parsed.raw,
+        };
+        if (status === 401) {
+            return new AuthenticationError(parsed.message, common);
+        }
+        if (status === 403) {
+            return new PermissionError(parsed.message, common);
+        }
+        if (status === 404) {
+            return new NotFoundError(parsed.message, common);
+        }
+        if (status === 409) {
+            return new ConflictError(parsed.message, common);
+        }
+        if (status === 429) {
+            return new RateLimitError(parsed.message, common);
+        }
+        if (status >= 500) {
+            return new ServerError(parsed.message, common);
+        }
+        return new InvalidRequestError(parsed.message, common);
+    }
+}
+function resolveFetch(customFetch) {
+    if (customFetch) {
+        return customFetch;
+    }
+    if (typeof fetch !== "function") {
+        throw new Error("Global fetch is not available. Inject a fetch implementation via Client options.");
+    }
+    return fetch;
+}
+function normalizeBaseUrl(baseUrl) {
+    if (!baseUrl) {
+        throw new Error("Client baseUrl cannot be empty.");
+    }
+    return baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+}
+function resolveDefaultAuth() {
+    const scheme = resolveAuthScheme(DEFAULT_AUTH_SCHEME);
+    if (scheme === "api_key_header") {
+        const headerName = DEFAULT_AUTH_HEADER_NAME;
+        return { scheme, headerName };
+    }
+    return { scheme };
+}
+function resolveAuthScheme(value) {
+    if (value === "basic" || value === "api_key_header" || value === "bearer") {
+        return value;
+    }
+    return "bearer";
+}
+function resolveEnvironmentBaseUrl(environment) {
+    if (environment === "sandbox") {
+        return SANDBOX_BASE_URL;
+    }
+    return PRODUCTION_BASE_URL;
+}
+function resolvePlaceholder(value) {
+    if (!value) {
+        return undefined;
+    }
+    if (value.includes("{{") && value.includes("}}")) {
+        return undefined;
+    }
+    return value;
+}
+function extractRequestId(headers) {
+    return headers.get("x-request-id") ?? headers.get("request-id") ?? undefined;
+}
+function extractRequestIdFromBody(body) {
+    if (!body || typeof body !== "object") {
+        return undefined;
+    }
+    const record = body;
+    if (typeof record.requestId === "string") {
+        return record.requestId;
+    }
+    if (typeof record.request_id === "string") {
+        return record.request_id;
+    }
+    return undefined;
+}
+function toMeta(raw) {
+    return {
+        status: raw.status,
+        headers: raw.headers,
+        requestId: raw.requestId,
+    };
+}
+function isDataEnvelope(value) {
+    return typeof value.success === "boolean" && "data" in value;
+}
+function isPaginatedEnvelope(value) {
+    return (typeof value.success === "boolean" &&
+        Array.isArray(value.data) &&
+        Boolean(value.metadata) &&
+        typeof value.metadata?.page === "number" &&
+        typeof value.metadata?.limit === "number" &&
+        typeof value.metadata?.total === "number");
+}
+function isRetryEligible(method, idempotencyKey) {
+    if (method === "GET" || method === "HEAD") {
+        return true;
+    }
+    if ((method === "POST" || method === "PUT") && Boolean(idempotencyKey)) {
+        return true;
+    }
+    return false;
+}
+async function parseBody(response) {
+    const contentType = response.headers.get("content-type") ?? "";
+    if (contentType.includes("application/json")) {
+        try {
+            return await response.json();
+        }
+        catch {
+            return null;
+        }
+    }
+    const text = await response.text();
+    if (!text) {
+        return null;
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+function parseRetryAfterMs(retryAfterValue) {
+    if (!retryAfterValue) {
+        return undefined;
+    }
+    const numeric = Number(retryAfterValue);
+    if (Number.isFinite(numeric)) {
+        return Math.max(0, numeric * 1_000);
+    }
+    const parsedDate = Date.parse(retryAfterValue);
+    if (!Number.isNaN(parsedDate)) {
+        return Math.max(0, parsedDate - Date.now());
+    }
+    return undefined;
+}
+function computeRetryDelayMs(attempt, retryAfterValue, baseDelayMs, maxDelayMs) {
+    const retryAfterMs = parseRetryAfterMs(retryAfterValue);
+    if (typeof retryAfterMs === "number") {
+        return Math.min(retryAfterMs, maxDelayMs);
+    }
+    const backoff = baseDelayMs * 2 ** attempt;
+    const jitter = Math.floor(Math.random() * baseDelayMs);
+    return Math.min(backoff + jitter, maxDelayMs);
+}
+function sleep(ms) {
+    if (ms <= 0) {
+        return Promise.resolve();
+    }
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isAbortError(error) {
+    if (error instanceof DOMException && error.name === "AbortError") {
+        return true;
+    }
+    if (!error || typeof error !== "object") {
+        return false;
+    }
+    return error.name === "AbortError";
+}
+function encodeBase64(input) {
+    if (typeof btoa === "function") {
+        return btoa(input);
+    }
+    const bytes = new TextEncoder().encode(input);
+    let binary = "";
+    for (const byte of bytes) {
+        binary += String.fromCharCode(byte);
+    }
+    if (typeof btoa !== "function") {
+        throw new Error("Base64 encoding is unavailable in this runtime.");
+    }
+    return btoa(binary);
+}
+function detectRuntime() {
+    if (typeof Deno !== "undefined") {
+        return "deno";
+    }
+    if (typeof Bun !== "undefined") {
+        return "bun";
+    }
+    return "node";
+}
+//# sourceMappingURL=client.js.map