@boelabs/billete-sdk 0.3.0

package/dist/events-BJuSt_4W.d.ts

@@ -0,0 +1,568 @@
+//#region ../contracts/src/environment.d.ts
+/**
+ * Environments and the credentials that name them. Kept free of runtime dependencies: the public
+ * SDK bundles this module to check API keys.
+ */
+/**
+ * Where an account operates. `test` is always available and moves no money; `production`
+ * charges for real. Every resource carries it, and secret keys name it: `sk_test_`, `sk_prod_`.
+ */
+declare const ENVIRONMENTS: readonly ["test", "production"];
+type Environment = (typeof ENVIRONMENTS)[number];
+/** Credentials that name their environment: secret keys and customer session tokens. */
+type TokenKind = "sk" | "cst";
+/** The prefix of a token for an environment, e.g. `sk_prod_`. */
+declare function tokenPrefix(kind: TokenKind, environment: Environment): string;
+/**
+ * The environment a token belongs to by its prefix, or `null` when it is not that kind of token.
+ */
+declare function tokenEnvironment(kind: TokenKind, token: string): Environment | null;
+//#endregion
+//#region ../contracts/src/common.d.ts
+/** Currencies Billete can price in. Availability depends on the registered payment providers. */
+declare const CURRENCIES: readonly ["VES", "USD", "EUR", "USDT"];
+type Currency = (typeof CURRENCIES)[number];
+/** Billing cycles, expressed in months, that a plan can offer. */
+declare const BILLING_MONTHS: readonly [1, 3, 6, 9, 12];
+type BillingMonths = (typeof BILLING_MONTHS)[number];
+/** Grace periods, in days, a merchant can grant after a renewal is missed. */
+declare const GRACE_PERIOD_DAYS: readonly [1, 3, 7];
+type GracePeriodDays = (typeof GRACE_PERIOD_DAYS)[number];
+/** `inclusive`: the price already contains the account tax. `exclusive`: tax is added on top. */
+declare const TAX_BEHAVIORS: readonly ["inclusive", "exclusive"];
+type TaxBehavior = (typeof TAX_BEHAVIORS)[number];
+type Metadata = Record<string, string>;
+/** A postal address as stored and returned. */
+interface Address {
+  line1: string;
+  line2?: string;
+  city: string;
+  state: string;
+  postalCode?: string;
+  /** ISO 3166-1 alpha-2. */
+  country: string;
+}
+/** An address as sent: `country` defaults to `VE`. */
+interface AddressInput {
+  line1: string;
+  line2?: string;
+  city: string;
+  state: string;
+  postalCode?: string;
+  country?: string;
+}
+/** Venezuelan mobile operators by prefix. */
+declare const MOBILE_PREFIXES: readonly [{
+  readonly prefix: "0412";
+  readonly operator: "Digitel";
+}, {
+  readonly prefix: "0414";
+  readonly operator: "Movistar";
+}, {
+  readonly prefix: "0416";
+  readonly operator: "Movilnet";
+}, {
+  readonly prefix: "0422";
+  readonly operator: "Digitel";
+}, {
+  readonly prefix: "0424";
+  readonly operator: "Movistar";
+}, {
+  readonly prefix: "0426";
+  readonly operator: "Movilnet";
+}];
+type MobilePrefix = (typeof MOBILE_PREFIXES)[number]["prefix"];
+/** Digits of a Venezuelan number in its national form: `+58 414-123.45.67` → `04141234567`. */
+declare function nationalPhone(value: string): string;
+/** `04141234567`: a known operator prefix and seven digits. */
+declare function isMobilePhone(value: string): boolean;
+/** `02121234567`: an area code starting with 02 and seven digits. */
+declare function isLandlinePhone(value: string): boolean;
+interface ListQuery {
+  /** 1-100, default 20. */
+  limit?: number;
+  cursor?: string;
+}
+interface List<T> {
+  data: T[];
+  /** Pass as `cursor` to fetch the next page; `null` on the last page. */
+  nextCursor: string | null;
+}
+/** ISO 8601 timestamp in UTC. */
+type Timestamp = string;
+//#endregion
+//#region ../contracts/src/errors.d.ts
+declare const API_ERROR_TYPES: readonly ["invalid_request", "authentication", "permission", "not_found", "conflict", "validation", "rate_limit", "provider", "internal"];
+type ApiErrorType = (typeof API_ERROR_TYPES)[number];
+interface ApiErrorBody {
+  type: ApiErrorType;
+  code: string;
+  message: string;
+  /** The request field that caused the error, when there is one. */
+  param?: string;
+  requestId?: string;
+}
+interface ApiErrorEnvelope {
+  error: ApiErrorBody;
+}
+/** Normalized payment failure codes, independent of the provider that produced them. */
+declare const PAYMENT_FAILURE_CODES: readonly ["insufficient_funds", "payment_not_found", "amount_mismatch", "invalid_details", "declined", "provider_unavailable"];
+type PaymentFailureCode = (typeof PAYMENT_FAILURE_CODES)[number];
+//#endregion
+//#region ../contracts/src/resources.d.ts
+interface Resource<TObject extends string> {
+  id: string;
+  object: TObject;
+  environment: Environment;
+  createdAt: Timestamp;
+}
+interface Customer extends Resource<"customer"> {
+  email: string;
+  name: string | null;
+  phone: string | null;
+  externalId: string | null;
+  address: Address | null;
+  metadata: Metadata;
+  updatedAt: Timestamp;
+}
+declare const PRODUCT_CATEGORIES: readonly ["digital", "physical", "service", "event", "other"];
+type ProductCategory = (typeof PRODUCT_CATEGORIES)[number];
+/** Who performed an action: a dashboard user or an API key. */
+type Actor = {
+  type: "user" | "api_key";
+  id: string;
+};
+interface Retirement {
+  retiredAt: Timestamp | null;
+  retiredBy: Actor | null;
+  retirementReason: string | null;
+}
+interface ProductVariant extends Retirement {
+  id: string;
+  name: string;
+  /** Free-form descriptors such as `{ color: "Rojo", talla: "M" }`. */
+  attributes: Record<string, string>;
+  amount: number;
+  /** Available units; null means unlimited. */
+  stock: number | null;
+  reserved: number;
+  isDefault: boolean;
+  active: boolean;
+}
+interface Product extends Resource<"product">, Retirement {
+  name: string;
+  description: string | null;
+  imageUrl: string | null;
+  category: ProductCategory;
+  currency: Currency;
+  /** Null when price and inventory belong to variants. */
+  amount: number | null;
+  stock: number | null;
+  reserved: number;
+  taxBehavior: TaxBehavior;
+  variants: ProductVariant[];
+  active: boolean;
+  metadata: Metadata;
+  updatedAt: Timestamp;
+}
+interface PlanPrice {
+  months: BillingMonths;
+  amount: number;
+}
+/**
+ * What a plan grants per feature key: `true`/`false` for `boolean`; a limit, or `null` for
+ * unlimited, for `metered` and `count`; the value itself for `number`.
+ */
+type PlanFeatureValues = Record<string, boolean | number | null>;
+interface Plan extends Resource<"plan"> {
+  name: string;
+  description: string | null;
+  currency: Currency;
+  prices: PlanPrice[];
+  trialDays: number;
+  gracePeriodDays: GracePeriodDays;
+  taxBehavior: TaxBehavior;
+  /** Marketing bullet points shown on checkout pages. */
+  highlights: string[];
+  features: PlanFeatureValues;
+  active: boolean;
+  metadata: Metadata;
+  updatedAt: Timestamp;
+}
+/**
+ * What a feature measures:
+ * - `boolean`: access, on or off (export to PDF, priority support).
+ * - `metered`: consumed and restored on a schedule (AI tokens, emails per day).
+ * - `count`: what the customer has now; it goes up and down and never resets (folders, seats).
+ * - `number`: a value the plan sets, with no usage (maximum upload size, days of history).
+ */
+declare const FEATURE_TYPES: readonly ["boolean", "metered", "count", "number"];
+type FeatureType = (typeof FEATURE_TYPES)[number];
+/** Types whose usage is recorded with `consume`, `release` and `set`. */
+declare const USAGE_FEATURE_TYPES: readonly ["metered", "count"];
+/** How often a `metered` feature restores its usage. */
+declare const RESET_FREQUENCIES: readonly ["billing", "day", "week", "month"];
+type ResetFrequency = (typeof RESET_FREQUENCIES)[number];
+/** ISO weekday: 1 is Monday, 7 is Sunday. */
+type Weekday = 1 | 2 | 3 | 4 | 5 | 6 | 7;
+/**
+ * When a `metered` feature starts over. `billing` follows each subscription's period; the others
+ * run on the account's clock (its time zone), at `hour`:00, every `interval` days, weeks or months
+ * counted from when the schedule was set.
+ */
+type FeatureReset = {
+  every: "billing";
+} | {
+  every: "day";
+  interval: number;
+  hour: number;
+} | {
+  every: "week";
+  interval: number;
+  hour: number;
+  weekday: Weekday;
+} | {
+  every: "month";
+  interval: number;
+  hour: number;
+  day: number;
+};
+interface Feature extends Resource<"feature"> {
+  key: string;
+  name: string;
+  type: FeatureType;
+  /** What is counted, for display (`tokens`, `carpetas`, `MB`). */
+  unit: string | null;
+  /** Only for `metered`; `null` otherwise. */
+  reset: FeatureReset | null;
+  /**
+   * Next restore of a clock-based schedule; `null` for `billing` (it depends on each subscription)
+   * and for the other types.
+   */
+  nextResetAt: Timestamp | null;
+}
+/** What a customer can do with a feature right now, across all of their ongoing subscriptions. */
+interface CustomerFeature {
+  key: string;
+  name: string;
+  type: FeatureType;
+  unit: string | null;
+  enabled: boolean;
+  /** `metered` and `count`: the limit, `null` meaning unlimited. `null` for the other types. */
+  limit: number | null;
+  /** `number`: the granted value (`null` when no plan grants it). `null` for the other types. */
+  value: number | null;
+  used: number;
+  /** `null` when unlimited or not a usage type. */
+  remaining: number | null;
+  /** When `metered` usage restores next; `null` for the other types. */
+  resetsAt: Timestamp | null;
+}
+interface FeatureUsageResult {
+  /** `false` when the requested consumption would exceed the limit; usage is then unchanged. */
+  allowed: boolean;
+  feature: CustomerFeature;
+}
+declare const SUBSCRIPTION_STATUSES: readonly ["trialing", "active", "past_due", "canceled", "expired"];
+type SubscriptionStatus = (typeof SUBSCRIPTION_STATUSES)[number];
+interface SubscriptionRenewal {
+  /** `upcoming`: not payable yet. `due`: payable before `dueAt`. `overdue`: in the grace period. */
+  status: "upcoming" | "due" | "overdue";
+  opensAt: Timestamp;
+  dueAt: Timestamp;
+  graceEndsAt: Timestamp;
+  /** Whole days left until access is lost (`dueAt` or, when overdue, `graceEndsAt`). */
+  daysRemaining: number;
+  amount: number;
+  currency: Currency;
+  checkoutId: string | null;
+  checkoutUrl: string | null;
+}
+interface Subscription extends Resource<"subscription"> {
+  customerId: string;
+  planId: string;
+  status: SubscriptionStatus;
+  months: BillingMonths;
+  amount: number;
+  currency: Currency;
+  currentPeriodStart: Timestamp;
+  currentPeriodEnd: Timestamp;
+  trialEndsAt: Timestamp | null;
+  cancelAtPeriodEnd: boolean;
+  canceledAt: Timestamp | null;
+  endedAt: Timestamp | null;
+  /** A plan or cycle change that takes effect on the next renewal. */
+  pendingChange: {
+    planId: string;
+    months: BillingMonths;
+  } | null;
+  renewal: SubscriptionRenewal | null;
+  metadata: Metadata;
+  updatedAt: Timestamp;
+}
+interface Coupon extends Resource<"coupon"> {
+  code: string;
+  name: string | null;
+  percentOff: number | null;
+  amountOff: number | null;
+  currency: Currency | null;
+  /** `forever` keeps discounting every renewal of a subscription bought with it. */
+  duration: "once" | "forever";
+  appliesTo: "all" | "products" | "plans";
+  maxRedemptions: number | null;
+  redemptions: number;
+  expiresAt: Timestamp | null;
+  active: boolean;
+}
+interface CollectSettings {
+  name: boolean;
+  phone: boolean;
+  address: boolean;
+}
+interface CustomField {
+  key: string;
+  label: string;
+  type: "text" | "number" | "select";
+  required: boolean;
+  options: string[] | null;
+}
+type AfterCompletion = {
+  type: "message";
+  message: string | null;
+} | {
+  type: "redirect";
+  url: string;
+};
+declare const SUBMIT_LABELS: readonly ["pay", "subscribe", "book", "donate"];
+type SubmitLabel = (typeof SUBMIT_LABELS)[number];
+interface QuantitySettings {
+  adjustable: boolean;
+  min: number;
+  max: number;
+}
+interface PaymentLink extends Resource<"payment_link">, Retirement {
+  url: string;
+  type: "product" | "plan";
+  productId: string | null;
+  /** Variants offered for a product link; `null` offers every active variant. */
+  variantIds: string[] | null;
+  quantity: QuantitySettings | null;
+  planId: string | null;
+  /** Billing cycles offered for a plan link; `null` offers every plan price. */
+  months: BillingMonths[] | null;
+  collect: CollectSettings;
+  customFields: CustomField[];
+  allowCoupons: boolean;
+  submitLabel: SubmitLabel;
+  afterCompletion: AfterCompletion;
+  maxPayments: number | null;
+  paymentCount: number;
+  active: boolean;
+  metadata: Metadata;
+  updatedAt: Timestamp;
+}
+interface CheckoutItem {
+  type: "product" | "plan";
+  productId: string | null;
+  variantId: string | null;
+  planId: string | null;
+  months: BillingMonths | null;
+  name: string;
+  quantity: number;
+  unitAmount: number;
+  amount: number;
+}
+interface CustomerDetails {
+  name: string | null;
+  phone: string | null;
+  address: Address | null;
+}
+declare const CHECKOUT_PURPOSES: readonly ["product", "plan", "renewal"];
+type CheckoutPurpose = (typeof CHECKOUT_PURPOSES)[number];
+interface Checkout extends Resource<"checkout"> {
+  url: string;
+  purpose: CheckoutPurpose;
+  status: "open" | "completed" | "expired";
+  customerId: string | null;
+  email: string | null;
+  items: CheckoutItem[];
+  currency: Currency;
+  subtotal: number;
+  discount: number;
+  tax: number;
+  total: number;
+  taxBehavior: TaxBehavior;
+  /**
+   * Plan checkouts with a free trial: nothing is due today and the subscription starts trialing.
+   */
+  trialDays: number | null;
+  couponCode: string | null;
+  subscriptionId: string | null;
+  paymentLinkId: string | null;
+  paymentId: string | null;
+  collect: CollectSettings;
+  customFields: CustomField[];
+  customFieldValues: Record<string, string | number>;
+  customerDetails: CustomerDetails;
+  successUrl: string | null;
+  expiresAt: Timestamp;
+  completedAt: Timestamp | null;
+  metadata: Metadata;
+}
+declare const RISK_LEVELS: readonly ["normal", "elevated", "high"];
+type RiskLevel = (typeof RISK_LEVELS)[number];
+interface PaymentFailure {
+  code: PaymentFailureCode;
+  message: string;
+  providerCode: string | null;
+}
+interface PaymentAttempt {
+  id: string;
+  status: "pending" | "succeeded" | "failed";
+  method: string;
+  amount: number;
+  currency: Currency;
+  exchangeRate: string | null;
+  providerReference: string | null;
+  failure: PaymentFailure | null;
+  createdAt: Timestamp;
+  completedAt: Timestamp | null;
+}
+declare const PAYMENT_STATUSES: readonly ["pending", "failed", "succeeded", "refunded", "partially_refunded"];
+type PaymentStatus = (typeof PAYMENT_STATUSES)[number];
+/** How the money actually moved: the charged currency, conversion, Billete fee and merchant net. */
+interface PaymentSettlement {
+  amount: number;
+  currency: Currency;
+  exchangeRate: string | null;
+  fee: number;
+  net: number;
+}
+interface Payment extends Resource<"payment"> {
+  checkoutId: string;
+  customerId: string;
+  subscriptionId: string | null;
+  status: PaymentStatus;
+  /** Checkout total in the price currency. */
+  amount: number;
+  currency: Currency;
+  tax: number;
+  settlement: PaymentSettlement | null;
+  amountRefunded: number;
+  method: string | null;
+  /** Masked, display-safe payment details (bank, last phone digits…). */
+  methodDetails: Record<string, string> | null;
+  failure: PaymentFailure | null;
+  risk: {
+    level: RiskLevel;
+    reasons: string[];
+  };
+  origin: {
+    ip: string | null;
+    userAgent: string | null;
+  };
+  attempts: PaymentAttempt[];
+  metadata: Metadata;
+  succeededAt: Timestamp | null;
+  updatedAt: Timestamp;
+}
+interface Refund extends Resource<"refund"> {
+  paymentId: string;
+  amount: number;
+  currency: Currency;
+  reason: string | null;
+  /** `manual`: the method cannot refund automatically; the merchant returned the funds. */
+  mode: "provider" | "manual";
+  status: "pending" | "succeeded" | "failed";
+}
+interface BalanceAmount {
+  amount: number;
+  currency: Currency;
+}
+interface Balance {
+  object: "balance";
+  environment: Environment;
+  /** Funds that can be paid out. */
+  available: BalanceAmount[];
+  /** Funds still inside the settlement hold. */
+  pending: BalanceAmount[];
+}
+interface Payout extends Resource<"payout"> {
+  amount: number;
+  currency: Currency;
+  status: "pending" | "in_transit" | "paid" | "failed" | "canceled";
+  automatic: boolean;
+  arrivalAt: Timestamp | null;
+  failureMessage: string | null;
+}
+interface WebhookEndpoint extends Resource<"webhook_endpoint"> {
+  url: string;
+  events: string[];
+  enabled: boolean;
+  /** Returned only when the endpoint is created. */
+  secret?: string;
+}
+interface Event<TData = Record<string, unknown>> extends Resource<"event"> {
+  type: string;
+  data: TData;
+}
+interface ExchangeRate {
+  object: "exchange_rate";
+  base: Currency;
+  quote: Currency;
+  rate: string;
+  source: string;
+  effectiveAt: Timestamp;
+}
+interface CurrencyAvailability {
+  object: "currency";
+  code: Currency;
+  active: boolean;
+  /** Payment methods that can settle a price in this currency. */
+  methods: string[];
+}
+interface CustomerSession {
+  object: "customer_session";
+  token: string;
+  customerId: string;
+  expiresAt: Timestamp;
+}
+//#endregion
+//#region ../contracts/src/events.d.ts
+interface EventDataMap {
+  "product.retired": Product;
+  "product.updated": Product;
+  "payment_link.retired": PaymentLink;
+  "customer.created": Customer;
+  "customer.updated": Customer;
+  "checkout.completed": Checkout;
+  "checkout.expired": Checkout;
+  "payment.succeeded": Payment;
+  "payment.failed": Payment;
+  "payment.refunded": Payment;
+  "refund.created": Refund;
+  "subscription.created": Subscription;
+  "subscription.updated": Subscription;
+  /** The renewal checkout is open; reminders start going out to the customer. */
+  "subscription.renewal_due": Subscription;
+  "subscription.renewed": Subscription;
+  /** The period ended unpaid; the customer keeps access until the grace period ends. */
+  "subscription.past_due": Subscription;
+  "subscription.canceled": Subscription;
+  /** Grace period over without payment; access is revoked. */
+  "subscription.expired": Subscription;
+}
+type EventType = keyof EventDataMap;
+declare const EVENT_TYPES: readonly ["product.retired", "product.updated", "payment_link.retired", "customer.created", "customer.updated", "checkout.completed", "checkout.expired", "payment.succeeded", "payment.failed", "payment.refunded", "refund.created", "subscription.created", "subscription.updated", "subscription.renewal_due", "subscription.renewed", "subscription.past_due", "subscription.canceled", "subscription.expired"];
+/** A delivered webhook, discriminated by `type` so `data` narrows automatically. */
+type WebhookEvent = { [TType in EventType]: {
+  id: string;
+  object: "event";
+  type: TType;
+  environment: Environment;
+  createdAt: string;
+  data: EventDataMap[TType];
+}; }[EventType];
+//#endregion
+export { Subscription as $, Payment as A, ENVIRONMENTS as At, Product as B, FEATURE_TYPES as C, MobilePrefix as Ct, FeatureUsageResult as D, isLandlinePhone as Dt, FeatureType as E, Timestamp as Et, PaymentStatus as F, RISK_LEVELS as G, ProductVariant as H, Payout as I, Retirement as J, Refund as K, Plan as L, PaymentFailure as M, TokenKind as Mt, PaymentLink as N, tokenEnvironment as Nt, PAYMENT_STATUSES as O, isMobilePhone as Ot, PaymentSettlement as P, tokenPrefix as Pt, SubmitLabel as Q, PlanFeatureValues as R, ExchangeRate as S, Metadata as St, FeatureReset as T, TaxBehavior as Tt, QuantitySettings as U, ProductCategory as V, RESET_FREQUENCIES as W, SUBMIT_LABELS as X, RiskLevel as Y, SUBSCRIPTION_STATUSES as Z, Customer as _, GRACE_PERIOD_DAYS as _t, Actor as a, API_ERROR_TYPES as at, CustomerSession as b, ListQuery as bt, BalanceAmount as c, ApiErrorType as ct, CheckoutItem as d, Address as dt, SubscriptionRenewal as et, CheckoutPurpose as f, AddressInput as ft, CustomField as g, Currency as gt, CurrencyAvailability as h, CURRENCIES as ht, WebhookEvent as i, Weekday as it, PaymentAttempt as j, Environment as jt, PRODUCT_CATEGORIES as k, nationalPhone as kt, CHECKOUT_PURPOSES as l, PAYMENT_FAILURE_CODES as lt, Coupon as m, BillingMonths as mt, EventDataMap as n, USAGE_FEATURE_TYPES as nt, AfterCompletion as o, ApiErrorBody as ot, CollectSettings as p, BILLING_MONTHS as pt, ResetFrequency as q, EventType as r, WebhookEndpoint as rt, Balance as s, ApiErrorEnvelope as st, EVENT_TYPES as t, SubscriptionStatus as tt, Checkout as u, PaymentFailureCode as ut, CustomerDetails as v, GracePeriodDays as vt, Feature as w, TAX_BEHAVIORS as wt, Event as x, MOBILE_PREFIXES as xt, CustomerFeature as y, List as yt, PlanPrice as z };
+//# sourceMappingURL=events-BJuSt_4W.d.ts.map

package/dist/http-ChElV20o.js

@@ -0,0 +1,124 @@
+//#region src/errors.ts
+/** Any failed Billete request. `type`/`code` are stable and safe to branch on. */
+var BilleteError = class extends Error {
+	type;
+	code;
+	status;
+	param;
+	requestId;
+	constructor(body, status) {
+		super(body.message);
+		this.name = "BilleteError";
+		this.type = body.type;
+		this.code = body.code;
+		this.status = status;
+		this.param = body.param;
+		this.requestId = body.requestId;
+	}
+};
+//#endregion
+//#region src/http.ts
+const SDK_VERSION = "0.3.0";
+const DEFAULT_BASE_URL = "https://api.billete.run";
+const RETRYABLE_STATUS = /* @__PURE__ */ new Set([
+	429,
+	500,
+	502,
+	503,
+	504
+]);
+function backoff(attempt, retryAfter) {
+	const seconds = retryAfter ? Number(retryAfter) : NaN;
+	return Number.isFinite(seconds) ? seconds * 1e3 : Math.min(500 * 2 ** attempt, 8e3);
+}
+function pause(ms, signal) {
+	return new Promise((resolve, reject) => {
+		const timer = setTimeout(resolve, ms);
+		signal?.addEventListener("abort", () => {
+			clearTimeout(timer);
+			reject(signal.reason);
+		}, { once: true });
+	});
+}
+function buildUrl(baseUrl, path, query) {
+	const url = new URL(path, baseUrl);
+	Object.entries(query ?? {}).filter(([, value]) => value !== void 0).forEach(([key, value]) => url.searchParams.set(key, String(value)));
+	return url;
+}
+/** A concurrent request with the same idempotency key is still running: worth retrying. */
+async function inProgress(response) {
+	return (await response.clone().json().catch(() => null))?.error.code === "idempotency_request_in_progress";
+}
+async function toError(response) {
+	return new BilleteError((await response.json().catch(() => null))?.error ?? {
+		type: "internal",
+		code: "invalid_response",
+		message: `Unexpected HTTP ${response.status} from Billete`,
+		requestId: response.headers.get("X-Request-Id") ?? void 0
+	}, response.status);
+}
+function createTransport(options) {
+	const baseUrl = options.baseUrl ?? DEFAULT_BASE_URL;
+	const fetchImpl = options.fetch ?? ((...args) => globalThis.fetch(...args));
+	const timeoutMs = options.timeoutMs ?? 3e4;
+	const maxRetries = options.maxRetries ?? 2;
+	async function send(request, idempotencyKey, attempt) {
+		const token = options.token?.();
+		const headers = {
+			Accept: "application/json",
+			"X-Billete-Client": `billete-js/${SDK_VERSION}`,
+			...token ? { Authorization: `Bearer ${token}` } : {},
+			...request.body === void 0 ? {} : { "Content-Type": "application/json" },
+			...idempotencyKey ? { "Idempotency-Key": idempotencyKey } : {}
+		};
+		const signals = [AbortSignal.timeout(timeoutMs), request.options?.signal].filter((signal) => signal !== void 0);
+		const response = await fetchImpl(buildUrl(baseUrl, request.path, request.query), {
+			method: request.method,
+			headers,
+			body: request.body === void 0 ? void 0 : JSON.stringify(request.body),
+			signal: AbortSignal.any(signals)
+		}).catch((error) => {
+			if (request.options?.signal?.aborted) throw error;
+			return error instanceof Error ? error : new Error(String(error));
+		});
+		if ((response instanceof Error || RETRYABLE_STATUS.has(response.status) || response.status === 409 && await inProgress(response)) && attempt < maxRetries) {
+			await pause(backoff(attempt, response instanceof Error ? null : response.headers.get("Retry-After")), request.options?.signal);
+			return send(request, idempotencyKey, attempt + 1);
+		}
+		if (response instanceof Error) throw new BilleteError({
+			type: "network",
+			code: "network_error",
+			message: `Could not reach Billete: ${response.message}`
+		}, 0);
+		if (!response.ok) throw await toError(response);
+		return response.status === 204 ? void 0 : await response.json();
+	}
+	function request(request) {
+		return send(request, request.method === "GET" ? void 0 : request.options?.idempotencyKey ?? globalThis.crypto.randomUUID(), 0);
+	}
+	/** Walks every page of a list endpoint. */
+	async function* paginate(path, query = {}) {
+		const page = await request({
+			method: "GET",
+			path,
+			query
+		});
+		yield* page.data;
+		if (page.nextCursor) yield* paginate(path, {
+			...query,
+			cursor: page.nextCursor
+		});
+	}
+	return {
+		request,
+		paginate
+	};
+}
+/** Encodes a path segment (customer references may be merchant-defined external IDs). */
+function segment(value) {
+	return encodeURIComponent(value);
+}
+//#endregion
+export { segment as n, BilleteError as r, createTransport as t };
+
+//# sourceMappingURL=http-ChElV20o.js.map