@usebillow/sdk 0.5.0

package/dist/index.d.cts

@@ -0,0 +1,2379 @@
+import { c as TaxBehavior, d as Customer, U as UnappliedPaymentReason, S as SavedPaymentMethod, e as CreateChargeInput, R as RequestOptions, f as Charge, g as CreateMerchantInitiatedChargeInput, I as IdempotentRequestOptions, h as CallOptions, i as PayInvoiceInput, C as CreateProductInput, j as UpdateProductInput, k as MigrationResult, l as CreateSubscriptionInput, B as BillowOptions, a as CreateCouponInput, m as Coupon, F as FeatureKind, M as MeterConfig, n as Feature, o as UpdateFeatureInput, p as UsageAlert, q as CreateUsageAlertInput, b as CheckResult, T as TrackResult, E as EntitlementView, A as AttachResult } from './billing-DZ4rIyg7.cjs';
+export { r as ActivatedSubscriptionResult, s as BillingInterval, t as ContractAddSubscriptionItemInput, u as ContractApplySubscriptionCouponInput, v as ContractCancelSubscriptionInput, w as ContractChangeSubscriptionPlanInput, x as ContractCreateChargeInput, y as ContractCreateCustomerInput, z as ContractCreateMerchantInitiatedChargeInput, D as ContractCreatePortalSessionInput, G as ContractCreateProductInput, H as ContractCreateSubscriptionInput, J as ContractCreateWebhookEndpointInput, K as ContractMigrateSubscribersInput, L as ContractRefundChargeInput, N as ContractResolveRefundInput, O as ContractUpdateProductInput, Q as ContractUpdateSubscriptionItemInput, V as ContractUpdateWebhookEndpointInput, W as CouponDuration, X as CouponKind, Y as CreateSubscriptionResult, Z as EntitlementInput, _ as InvoicePaymentResult, $ as MeterAggregation, a0 as MeterFilter, a1 as MeterRoundingMode, a2 as PendingSubscriptionCheckoutResult, a3 as PriceInput, P as Product, a4 as ProductEntitlement, a5 as ProductPrice, a6 as Subscription, a7 as SubscriptionDetail, a8 as SubscriptionItem, a9 as UpdatePriceInput, aa as UsageAlertKind, ab as UsageAlertMetric, ac as UsageModel, ad as UsageTier } from './billing-DZ4rIyg7.cjs';
+import { C as ChargeStatus, P as PaymentMethodStatus, I as InvoiceStatus, R as RefundStatus, W as WebhookDeliveryStatus } from './billing-status-BZQN_gm7.cjs';
+export { a as CHARGE_STATUSES, b as INVOICE_STATUSES, c as PAYMENT_METHOD_STATUSES, d as REFUND_STATUSES, e as WEBHOOK_DELIVERY_STATUSES } from './billing-status-BZQN_gm7.cjs';
+import { SubscriptionStatus } from './status.cjs';
+export { ACTIVE_SUBSCRIPTION_STATUSES, NEVER_ACTIVATED_SUBSCRIPTION_STATUSES, SUBSCRIPTION_STATUSES, TERMINAL_SUBSCRIPTION_STATUSES, grantsAccess, isTerminal } from './status.cjs';
+import { a as CreditThresholdLevel, b as CreditGrant, c as CreditTopUp, d as CreateCreditGrantInput, e as CreditGrantRequestResult, f as CreditPacks, g as CreateCreditPackInput, h as CreditPack, U as UpdateCreditPackInput, i as CreateCreditTopUpInput, j as CreditTopUpRequestResult, k as CreditTopUpListParams, l as CreditBalance, m as CreditLedgerEntry, n as CreditUsageParams, o as CreditUsage } from './credits-C3Fe3TO0.cjs';
+export { p as CreditAccountStatus, C as CreditGrantKind, q as CreditMoney, r as CreditPackListItem, s as CreditTopUpStatus, t as CreditTransactionType, u as CreditUsageGroupBy } from './credits-C3Fe3TO0.cjs';
+import 'zod';
+
+/**
+ * The machine-readable error codes billow returns on `BillowApiError.code`. Mirrored from
+ * `@billow/core`'s `BILLOW_ERROR_CODES` (the server's source of truth) — the SDK carries no
+ * runtime dependency on core, so `error-codes.test.ts` asserts this list stays in lockstep.
+ *
+ * `switch` on these for programmatic handling (e.g. surface `rate_limited` vs `validation_error`
+ * differently). The `code` field stays widened to `string` for forward-compatibility, so a code a
+ * newer server adds never breaks type-checking against an older SDK.
+ */
+declare const BILLOW_ERROR_CODES: readonly ["not_found", "validation_error", "authentication_error", "api_key_expired", "permission_denied", "conflict", "invalid_state_transition", "provider_error", "rate_limited", "quota_exceeded", "internal_error", "insufficient_credits", "account_frozen", "account_closed", "idempotency_conflict", "commit_exceeds_hold", "reversal_exceeds_consumption"];
+type BillowErrorCode = (typeof BILLOW_ERROR_CODES)[number];
+
+/** Public SDK types for this domain. Re-exported by ../types.ts. */
+
+/** A payment provider's declarative admin surface (rendered into the credentials form). */
+interface PaymentProviderDefinition {
+    /** Registry key + `payment_credentials.provider` discriminator (e.g. "paymob"). */
+    provider: string;
+    label: string;
+    /** Config-field manifest; secret fields are stored encrypted and never returned. */
+    fields: ConfigField[];
+    /** Customer-present checkout methods this provider can offer. */
+    methods: ("card" | "wallet" | "sympl" | "applepay")[];
+    /** Live verify targets the dashboard can "Test". */
+    verifyTargets: ProviderVerifyTarget[];
+    /**
+     * When present, the dashboard surfaces a copy-able webhook URL to register in the
+     * provider's own dashboard (e.g. Stripe). Omitted for providers that set their
+     * callback per-charge (Paymob). `events` is an optional hint list; `url` is the
+     * tenant's full endpoint, filled in by the API per (org, environment).
+     */
+    webhook?: {
+        events?: string[];
+        url?: string;
+    };
+}
+/** One customer-present checkout method offered for a currency (for a method picker). */
+interface CheckoutMethodInfo {
+    method: "card" | "wallet" | "sympl" | "applepay";
+    label: string;
+    /** Customer surcharge applied to this method's checkout total, in basis points. */
+    feeBps?: number;
+}
+/** A verify target the dashboard can "Test" (key + label, optional integration field). */
+interface ProviderVerifyTarget {
+    key: string;
+    label: string;
+    /**
+     * The non-secret config field holding this target's integration id (the box's
+     * primary field). Set ⇒ the dashboard renders the target as its own integration
+     * box; absent ⇒ an account-level probe shown in the credentials card.
+     */
+    fieldKey?: string;
+    /** Additional non-secret config fields rendered inside the same integration box. */
+    extraFieldKeys?: string[];
+    /** Short helper text shown under the integration box. */
+    help?: string;
+}
+/** One verify target's live verdict. */
+interface ProviderVerifyTargetResult {
+    /** The target key probed (matches a `PaymentProviderDefinition.verifyTargets` key). */
+    target: string;
+    configured: boolean;
+    /** The provider validated this target's config against its live API. */
+    valid: boolean;
+    /** HTTP status of the probe (0 = not configured / transport error). */
+    status: number;
+    detail: string;
+    /** Provider-specific extra detail (e.g. Paymob's gateway type). */
+    meta?: Record<string, string>;
+    /** Present only for a functional (money-moving) sub-test. */
+    functional?: {
+        ok: boolean;
+        status: number;
+        detail: string;
+    };
+}
+interface ProviderVerifyResult {
+    provider: string;
+    currency: string;
+    targets: ProviderVerifyTargetResult[];
+}
+/** A credential set's non-secret surface (provider + currency + stored config). */
+interface ProviderCredentialSummary {
+    provider: string;
+    currency: string;
+    config: Record<string, unknown>;
+}
+/** The editable view of one credential set — secret values are never returned. */
+interface CredentialSet {
+    provider: string;
+    currency: string;
+    /** Stored non-secret field values, keyed by manifest field key (pre-fills the form). */
+    config: Record<string, unknown>;
+    /** Which secret fields currently have a value stored (the value is never returned). */
+    secretsSet: Record<string, boolean>;
+    updatedAt: string;
+}
+/**
+ * Create or rotate a credential set. `values` carries each field keyed by the
+ * provider definition's field key. On first create all required secrets are
+ * required; on update omit a secret to keep the stored one, send "" to clear a
+ * non-secret field, omit a field to leave it unchanged.
+ */
+interface UpsertCredentialsInput {
+    provider: string;
+    currency: string;
+    values: Record<string, unknown>;
+}
+/** The merchant's customer-facing business identity (seller block + email from-name). */
+interface BusinessProfile {
+    displayName: string | null;
+    legalName: string | null;
+    address: string | null;
+    /** Contact phone (PRD-02). */
+    phone: string | null;
+    /** ISO-3166-1 alpha-2 country code, e.g. "EG" (PRD-02). */
+    country: string | null;
+    taxId: string | null;
+    supportEmail: string | null;
+    /** Logo image URL rendered on documents + emails; null = name-only branding. */
+    logoUrl: string | null;
+    /** Brand/accent color as `#RRGGBB` (PRD-11); null = billow's default accent. */
+    brandColor: string | null;
+    /** Org-default tax treatment (Phase E) — every taxable price inherits this. */
+    taxEnabled: boolean;
+    /** Default rate in basis points (1% = 100 bps), e.g. 1400 for Egypt's 14% VAT. */
+    taxRateBps: number;
+    taxBehavior: TaxBehavior;
+    /** What the tax is called on documents (e.g. "VAT"); null falls back to "Tax". */
+    taxLabel: string | null;
+    updatedAt: string;
+}
+/** Update a business profile; omit a field to leave it unchanged, send "" to clear it. */
+interface UpdateBusinessProfileInput {
+    displayName?: string;
+    legalName?: string;
+    address?: string;
+    phone?: string;
+    country?: string;
+    taxId?: string;
+    supportEmail?: string;
+    logoUrl?: string;
+    /** `#RRGGBB` hex; empty string clears it (PRD-11). */
+    brandColor?: string;
+    taxEnabled?: boolean;
+    taxRateBps?: number;
+    taxBehavior?: TaxBehavior;
+    taxLabel?: string;
+}
+type IntegrationKind = "email" | "accounting";
+type IntegrationTier = "official" | "community";
+type ConfigFieldType = "text" | "password" | "email" | "url" | "number" | "percent" | "boolean" | "select";
+interface ConfigFieldOption {
+    value: string;
+    label: string;
+}
+/** One field in an Integration's config manifest (the dashboard renders these). */
+interface ConfigField {
+    key: string;
+    label: string;
+    type: ConfigFieldType;
+    /** Secret values are stored encrypted and never returned by a read. */
+    secret?: boolean;
+    required?: boolean;
+    placeholder?: string;
+    help?: string;
+    options?: ConfigFieldOption[];
+    default?: string | number | boolean;
+}
+/** A catalog Integration's declarative definition. */
+interface IntegrationDefinition {
+    slug: string;
+    name: string;
+    kind: IntegrationKind;
+    tier: IntegrationTier;
+    summary: string;
+    description?: string;
+    fields: ConfigField[];
+    docsUrl?: string;
+}
+/** A catalog entry: the definition plus this tenant's install state. */
+interface CatalogItem {
+    definition: IntegrationDefinition;
+    installed: boolean;
+    enabled: boolean;
+    /** Stored non-secret config values, for pre-filling the form. */
+    config: Record<string, unknown>;
+    /** Which secret fields have a value stored (the value itself is never returned). */
+    secretsSet: Record<string, boolean>;
+    /** Result of the last test/verify probe; null until tested (reset on reconfigure). */
+    lastTestStatus: "ok" | "error" | null;
+    /** Failure message from the last test, when it errored. */
+    lastTestError: string | null;
+    /** When the last test/verify probe ran (ISO), or null if never tested. */
+    lastTestedAt: string | null;
+    updatedAt: string | null;
+}
+/** A config field carries a secret value when explicitly marked or password-typed. */
+declare function isSecretField(field: ConfigField): boolean;
+
+/** Public SDK types for this domain. Re-exported by ../types.ts. */
+
+/** The envelope every paginated list endpoint returns. */
+interface Paginated<T> {
+    data: T[];
+    total: number;
+    limit: number;
+    offset: number;
+}
+/**
+ * The return type of every paginated `.list()`: BOTH a Promise for the first page AND
+ * async-iterable across ALL pages.
+ *
+ * - `await client.x.list(params)` → the first `Paginated<T>` page. `ListPromise<T>` is a
+ *   structural subtype of the pre-pagination `Promise<Paginated<T>>`, so existing callers that
+ *   `await` and read `.data` are unaffected.
+ * - `for await (const item of client.x.list(params))` → walks every page transparently.
+ * - `await client.x.list(params).listAll()` → collects every item into one array.
+ *
+ * Auto-pagination never reads `total` (it stops when a page comes back shorter than the page
+ * size), so it is correct under concurrent inserts/deletes; a list that grows at its head pages
+ * by cursor instead ({@link CursorListPromise}). The caller's {@link CallOptions} (`signal` /
+ * `timeoutMs`) apply to EVERY page
+ * fetch — an abort stops the walk mid-stream; `timeoutMs` is per page.
+ *
+ * A returned value is ONE walk: page 1 is cached on it (so `await` then `for await` on the same
+ * value fetch page 1 once), which means iterating the same value again later reuses that first
+ * page. For a fresh walk, call `.list()` again.
+ */
+interface ListPromise<T> extends Promise<Paginated<T>>, AsyncIterable<T> {
+    /** Page through the entire list and collect every item into one array. */
+    listAll(): Promise<T[]>;
+}
+interface ListParams {
+    limit?: number;
+    offset?: number;
+}
+/**
+ * The cursor-mode envelope, for a list whose rows keep arriving at the head (the credit ledger):
+ * pass `nextCursor` back as `cursor` for the next page; it is null on the last page.
+ */
+interface CursorPaginated<T> {
+    data: T[];
+    limit: number;
+    nextCursor: string | null;
+}
+/**
+ * The return type of a cursor-paginated `.list()`: like {@link ListPromise}, BOTH a Promise for
+ * the first page AND async-iterable across ALL pages (`for await`, or `.listAll()`). The walk
+ * follows `nextCursor` until it is null, so rows arriving at the head meanwhile never make it skip
+ * or repeat a row.
+ */
+interface CursorListPromise<T> extends Promise<CursorPaginated<T>>, AsyncIterable<T> {
+    /** Page through the entire list and collect every item into one array. */
+    listAll(): Promise<T[]>;
+}
+interface CursorListParams {
+    /** Page size: 1 to 100 (default 25); the server clamps a larger one. */
+    limit?: number;
+    /** A `nextCursor` to continue from; omit to start at the newest row. */
+    cursor?: string;
+}
+interface CustomerListItem {
+    id: string;
+    externalId: string;
+    name: string | null;
+    email: string | null;
+    phone: string | null;
+    subscriptionCount: number;
+    createdAt: string;
+}
+interface CustomerListParams extends ListParams {
+    /** Search across external id / email / name. */
+    q?: string;
+}
+interface PaymentMethod {
+    id: string;
+    brand: string | null;
+    last4: string | null;
+    expMonth: number | null;
+    expYear: number | null;
+    isDefault: boolean;
+    status: PaymentMethodStatus;
+    createdAt: string;
+}
+type EmailDeliveryStatus = "pending" | "sent" | "failed" | "skipped";
+interface EmailDeliveryListItem {
+    id: string;
+    template: string;
+    recipient: string | null;
+    status: EmailDeliveryStatus | string;
+    attempts: number;
+    nextAttemptAt: string | null;
+    lastError: string | null;
+    sentAt: string | null;
+    createdAt: string;
+}
+interface EmailDeliveryListParams extends ListParams {
+    status?: EmailDeliveryStatus;
+}
+type OutboxEventStatus = "pending" | "delivered" | "failed";
+interface OutboxEventListItem {
+    id: string;
+    type: string;
+    status: OutboxEventStatus;
+    attempts: number;
+    /** Failure reason from the most recent delivery attempt (null if none / delivered). */
+    error: string | null;
+    /** HTTP status of the most recent delivery attempt, if any. */
+    lastResponseStatus: number | null;
+    nextAttemptAt: string | null;
+    availableAt: string;
+    deliveredAt: string | null;
+    createdAt: string;
+}
+interface OutboxEventListParams extends ListParams {
+    status?: OutboxEventStatus;
+}
+type InboundWebhookOutcome = "signature_failed" | "shape_rejected" | "replayed" | "matched" | "unmatched" | "dispute_matched" | "dispute_unknown" | "dispute_deferred" | "accepted";
+interface InboundWebhookListItem {
+    id: string;
+    provider: string;
+    outcome: InboundWebhookOutcome | string;
+    eventType: string | null;
+    providerEventId: string | null;
+    reference: string | null;
+    providerTransactionId: string | null;
+    /** The HTTP status billow returned to the provider (200 / 401 / 503). */
+    httpStatus: number;
+    detail: string | null;
+    createdAt: string;
+}
+interface InboundWebhookListParams extends ListParams {
+    outcome?: InboundWebhookOutcome;
+}
+interface CustomerUsage {
+    /** The metered feature's slug. */
+    feature: string;
+    /** Granted units this period; null = unlimited. */
+    allowance: number | null;
+    /** Gross units used this period (sum of positive events in the period). */
+    used: number;
+    /** Units topped up this period — gross credit-backs (negative events). */
+    added: number;
+    /** Remaining = allowance + added − used; null = unlimited. May be negative (overage). */
+    remaining: number | null;
+    /** Per-subscription counters in the order usage is consumed. */
+    details?: CustomerUsageDetail[];
+}
+interface CustomerUsageDetail {
+    subscriptionId: string;
+    productSlug: string;
+    productName: string;
+    status: SubscriptionStatus;
+    cancelAtPeriodEnd: boolean;
+    periodStart: string | null;
+    periodEnd: string | null;
+    allowance: number | null;
+    used: number;
+    remaining: number | null;
+}
+interface ChargeListItem {
+    id: string;
+    subtotal: number;
+    tax: number;
+    total: number;
+    taxRateBps: number | null;
+    taxBehavior: TaxBehavior | null;
+    /** Backward-compatible alias of `total`. */
+    amount: number;
+    currency: string;
+    status: ChargeStatus;
+    kind: "customer_present" | "mit";
+    customerExternalId: string;
+    customerEmail: string | null;
+    invoiceId: string | null;
+    specialReference: string;
+    providerTransactionId: string | null;
+    errorMessage: string | null;
+    /** Provider-reported dispute/chargeback (PRD-08), read-only. Null unless disputed. */
+    disputedAt: string | null;
+    disputeReason: string | null;
+    disputeState: "open" | "won" | "lost" | null;
+    providerDisputeId: string | null;
+    disputeAmount: number | null;
+    /** Set when this payment could not be applied to its invoice; null otherwise. */
+    unappliedReason: UnappliedPaymentReason | null;
+    createdAt: string;
+}
+interface ChargeListParams extends ListParams {
+    status?: ChargeStatus;
+    currency?: string;
+    /** Customer external id. */
+    customer?: string;
+    /** ISO-8601 lower bound (inclusive) on createdAt. */
+    from?: string;
+    /** ISO-8601 upper bound (inclusive) on createdAt. */
+    to?: string;
+    /** Filter by invoice membership: `false` = one-off charges only (receipts), `true` = invoice-backed only. */
+    hasInvoice?: boolean;
+}
+interface SubscriptionListItem {
+    id: string;
+    status: SubscriptionStatus;
+    customerExternalId: string;
+    productId: string;
+    productSlug: string;
+    productName: string;
+    /** The plan's metadata map (Stripe-style); `{}` when it carries none. */
+    productMetadata: Record<string, string>;
+    comp: boolean;
+    /** The subscription's billing currency (Phase F, ADR-0013). */
+    currency: string;
+    currentPeriodStart: string | null;
+    currentPeriodEnd: string | null;
+    trialEnd: string | null;
+    cancelAtPeriodEnd: boolean;
+    scheduledChange: ScheduledSubscriptionChange | null;
+    /** Renewals left before a limited-term subscription ends; null = open-ended. */
+    remainingCycles: number | null;
+    /** Failed-renewal retries run so far (PRD-06 dunning) — 0 until a renewal fails. */
+    dunningAttempts: number;
+    /** ISO-8601 time the next dunning retry is due; null when not in dunning (PRD-09). */
+    nextDunningAt: string | null;
+    createdAt: string;
+}
+interface ScheduledSubscriptionChange {
+    productVersionId: string;
+    productId: string;
+    productSlug: string;
+    productName: string;
+    effectiveAt: string | null;
+}
+interface SubscriptionListParams extends ListParams {
+    status?: SubscriptionStatus;
+    /** Customer external id. */
+    customer?: string;
+}
+/** A manually-maintained FX rate for cross-currency reporting (Phase F, ADR-0013). */
+interface ExchangeRate {
+    baseCurrency: string;
+    quoteCurrency: string;
+    /** Quote per base, decimal (e.g. 0.020408 USD per EGP). */
+    rate: number;
+}
+/**
+ * One transactional email template, merged with the project's overrides (PRD-10).
+ * The subject/message are `{{variable}}` templates over the server-defined
+ * `variables` allowlist; every template has a code default that renders when no
+ * override is set.
+ */
+interface EmailTemplateSetting {
+    /** Template key, e.g. "receipt", "payment_failed", "usage_cap". */
+    key: string;
+    label: string;
+    description: string;
+    /** The code-default subject (itself a `{{variable}}` template). */
+    defaultSubject: string;
+    /** The variables the subject/message may reference (without braces). */
+    variables: string[];
+    /** False for compliance-required templates (the receipt) — can't be disabled. */
+    canDisable: boolean;
+    /** Subject override, or null when the default is in effect. */
+    subject: string | null;
+    /** Custom message paragraph inserted after the greeting, or null. */
+    customMessage: string | null;
+    enabled: boolean;
+}
+interface UpdateEmailTemplateInput {
+    /** Subject override; null/"" resets to the default. Omit to keep. */
+    subject?: string | null;
+    /** Custom message paragraph; null/"" removes it. Omit to keep. */
+    customMessage?: string | null;
+    /** Omit to keep. Disabling a compliance-required template is rejected. */
+    enabled?: boolean;
+}
+interface CustomerOverview {
+    customer: Customer;
+    subscriptions: SubscriptionListItem[];
+    charges: ChargeListItem[];
+    paymentMethods: PaymentMethod[];
+    usage: CustomerUsage[];
+}
+interface CustomerSearchHit {
+    id: string;
+    externalId: string;
+    name: string | null;
+    email: string | null;
+}
+interface InvoiceSearchHit {
+    id: string;
+    number: string | null;
+    status: InvoiceStatus;
+    total: number;
+    currency: string;
+    customerExternalId: string;
+}
+interface SubscriptionSearchHit {
+    id: string;
+    status: SubscriptionStatus;
+    productName: string;
+    customerExternalId: string;
+}
+interface ChargeSearchHit {
+    id: string;
+    amount: number;
+    currency: string;
+    status: ChargeStatus;
+    /** The charge's idempotency reference (`special_reference`). */
+    reference: string;
+    customerExternalId: string;
+}
+interface SearchResults {
+    customers: CustomerSearchHit[];
+    invoices: InvoiceSearchHit[];
+    subscriptions: SubscriptionSearchHit[];
+    charges: ChargeSearchHit[];
+}
+interface Invoice {
+    id: string;
+    status: InvoiceStatus;
+    customerId: string;
+    subscriptionId: string | null;
+    subtotal: number;
+    discountTotal: number;
+    usageTotal: number;
+    /** Tax/VAT amount (minor units); also recorded against the tax ids below. */
+    taxTotal: number;
+    /** Tax rate in basis points snapshotted at issue; null = untaxed. */
+    taxRateBps: number | null;
+    /** The tax treatment snapshotted at issue; null = untaxed. Inclusive tax is already in `total`. */
+    taxBehavior: TaxBehavior | null;
+    /** The customer's tax id snapshotted at issue (null if none). */
+    customerTaxId: string | null;
+    /** The merchant's tax registration snapshotted at issue (null if none). */
+    merchantTaxId: string | null;
+    total: number;
+    currency: string;
+    /**
+     * Cross-currency reporting snapshot (Phase F, ADR-0013). `reportingCurrency` is the
+     * org's reporting currency at issue; `fxRate` converts this invoice's `currency`
+     * into it (1.0 when the same). Both null = no reporting currency configured; a
+     * non-null `reportingCurrency` with a null `fxRate` = no rate was on file (this
+     * invoice can't be rolled up).
+     */
+    reportingCurrency: string | null;
+    fxRate: number | null;
+    periodStart: string | null;
+    periodEnd: string | null;
+    createdAt: string;
+}
+interface InvoiceLineItem {
+    id: string;
+    invoiceId: string;
+    type: string;
+    description: string | null;
+    amount: number;
+    quantity: number;
+    currency: string;
+}
+interface InvoiceListItem {
+    id: string;
+    /** Sequential invoice number, snapshotted when paid; null if not yet assigned. */
+    number: string | null;
+    status: InvoiceStatus;
+    total: number;
+    currency: string;
+    customerExternalId: string;
+    subscriptionId: string | null;
+    /** What the invoice is for — the plan name (subscriptions) or first line item. */
+    reason: string | null;
+    periodStart: string | null;
+    periodEnd: string | null;
+    createdAt: string;
+    /** When the invoice was paid (null if unpaid). */
+    paidAt: string | null;
+    /** The settling charge's receipt number (paid invoices only); null otherwise. */
+    receiptNumber: string | null;
+}
+interface InvoiceListParams extends ListParams {
+    status?: InvoiceStatus;
+    /** Customer external id. */
+    customer?: string;
+    from?: string;
+    to?: string;
+}
+interface InvoiceDetail {
+    invoice: Invoice;
+    lineItems: InvoiceLineItem[];
+}
+/** How an offline payment was collected (ADR-0026). `other` is the escape hatch. */
+type ExternalPaymentMethod = "bank_transfer" | "cash" | "cheque" | "other";
+/**
+ * Record that an open invoice was paid outside the gateway. `amount` must equal the invoice
+ * total (full settlement only); `reference` carries the operator's detail (transfer id, etc.).
+ */
+interface RecordExternalPaymentInput {
+    amount: number;
+    method: ExternalPaymentMethod;
+    reference?: string;
+    /** ISO-8601 time the payment was received; defaults to now. */
+    paidAt?: string;
+}
+/** The settling charge recorded for an external payment. */
+interface ExternalPaymentResult {
+    id: string;
+    invoiceId: string | null;
+    amount: number;
+    currency: string;
+    status: ChargeStatus;
+    receiptNumber: string | null;
+    method: ExternalPaymentMethod | null;
+    reference: string | null;
+    paidAt: string | null;
+}
+interface MetricsOverview {
+    currency: string;
+    from: string;
+    to: string;
+    /** Monthly recurring revenue (minor units). */
+    mrr: number;
+    /** Annual recurring revenue (minor units) — `mrr × 12`. */
+    arr: number;
+    /** Cohort subscription churn over the window (0..1); null if none were active at its start. */
+    churnRate: number | null;
+    activeSubscriptions: number;
+    pastDueSubscriptions: number;
+    revenue: number;
+    newCustomers: number;
+    newSubscriptions: number;
+    canceledSubscriptions: number;
+    failedCharges: number;
+    /** Succeeded / (succeeded + failed); 0..1, or null if no attempts in the window. */
+    successRate: number | null;
+}
+/**
+ * KPIs rolled up into the org's reporting currency across all billing currencies
+ * (Phase H, ADR-0013). `metrics.rollup` returns `null` when no reporting currency
+ * is configured. Money figures are in `reportingCurrency` (minor units); MRR/ARR
+ * convert at the current stored rate, revenue at each invoice's FX snapshot.
+ */
+interface MetricsRollup {
+    reportingCurrency: string;
+    from: string;
+    to: string;
+    mrr: number;
+    arr: number;
+    revenue: number;
+    activeSubscriptions: number;
+    pastDueSubscriptions: number;
+    newCustomers: number;
+    newSubscriptions: number;
+    canceledSubscriptions: number;
+    churnRate: number | null;
+    failedCharges: number;
+    successRate: number | null;
+    /** Currencies excluded from mrr/revenue for want of a rate (surfaced, never guessed). */
+    unconvertibleCurrencies: string[];
+}
+type TimeseriesMetric = "revenue" | "mrr" | "new_subscriptions" | "canceled_subscriptions" | "success_rate";
+type TimeseriesInterval = "day" | "week" | "month";
+interface TimeseriesPoint {
+    bucket: string;
+    value: number;
+}
+interface TimeseriesResult {
+    metric: TimeseriesMetric;
+    currency: string;
+    interval: TimeseriesInterval;
+    points: TimeseriesPoint[];
+}
+interface MetricsParams {
+    currency?: string;
+    from?: string;
+    to?: string;
+}
+interface TimeseriesParams extends MetricsParams {
+    metric?: TimeseriesMetric;
+    interval?: TimeseriesInterval;
+}
+interface Whoami {
+    /** The apex account that owns the Project (ADR-0020). */
+    organizationId: string;
+    organizationName: string | null;
+    organizationSlug: string | null;
+    /** The billing workspace the API key scopes to — what every resource belongs to. */
+    projectId: string;
+    projectName: string | null;
+    projectSlug: string | null;
+    environment: "sandbox" | "live";
+    apiKeyType: string;
+    /** Currencies configured for this Project (payment credential sets). */
+    currencies: string[];
+    defaultCurrency: string;
+}
+
+/** What surface a portal session lands the Customer on. */
+type PortalSessionFlow = "portal" | "checkout";
+interface CreatePortalSessionInput {
+    /** The Customer's developer-supplied id. */
+    customerId: string;
+    /** Which surface to land on; defaults to the self-serve portal. */
+    flow?: PortalSessionFlow;
+    /** Product slug to subscribe to — required when `flow` is `checkout`. */
+    productId?: string;
+    /** Where the surface returns the Customer when they finish or exit. */
+    returnUrl?: string;
+}
+/** The minted portal session: redirect the Customer to `url` (it carries the bearer). */
+interface PortalSession {
+    id: string;
+    url: string;
+    flow: PortalSessionFlow;
+    /** ISO-8601 expiry — the session (and its URL) stop working after this. */
+    expiresAt: string;
+}
+/**
+ * The portal shell: the session's flow + return URL, the merchant's
+ * customer-facing brand, and the Customer's identity. The lightweight payload a
+ * hosting app frames every page with (no subscription/usage load), and the
+ * validate-and-route check at login.
+ */
+interface PortalSessionInfo {
+    flow: PortalSessionFlow;
+    returnUrl: string | null;
+    /** The merchant's customer-facing brand (name + support + logo + accent) and the
+     *  white-label mark gate (PRD-11). */
+    business: {
+        name: string;
+        supportEmail: string | null;
+        logoUrl: string | null;
+        brandColor: string | null;
+        showBillowMark: boolean;
+    };
+    /** The session's Customer (the only identity the portal shell needs). */
+    customer: {
+        externalId: string;
+        name: string | null;
+        email: string | null;
+    };
+}
+/** The self-serve home payload returned to the portal app (`BillowPortal.me`). */
+interface PortalView {
+    customer: {
+        id: string;
+        externalId: string;
+        name: string | null;
+        email: string | null;
+    };
+    flow: PortalSessionFlow;
+    returnUrl: string | null;
+    subscriptions: SubscriptionListItem[];
+    usage: CustomerUsage[];
+    paymentMethods: SavedPaymentMethod[];
+}
+/** The subscription's state after a portal cancel (scheduled at period end). */
+interface PortalSubscriptionStatus {
+    id: string;
+    status: string;
+    cancelAtPeriodEnd: boolean;
+    currentPeriodEnd: string | null;
+    scheduledChange: ScheduledSubscriptionChange | null;
+}
+/** The outcome of a portal-driven plan change (PRD-15). */
+interface PortalPlanChange {
+    /** upgrade = prorated + charged now; downgrade = scheduled for period end; noop = same plan. */
+    kind: "upgrade" | "downgrade" | "noop";
+    subscription: PortalSubscriptionStatus;
+    /** Upgrade only: the proration invoice raised for the prorated delta, when non-zero. */
+    prorationInvoiceId?: string;
+    /** Upgrade only: the proration charge's status (`succeeded`/`failed`/`processing`/`pending`) —
+     *  present when an immediate charge was raised, so a client can surface an unresolved payment. */
+    chargeStatus?: string;
+}
+/** The checkout URL to redirect the Customer to for a card update (null if none). */
+interface PortalCardSetupResult {
+    checkoutUrl: string | null;
+}
+/** The plan a `checkout` portal session is confirming (product + its base price). */
+interface PortalCheckout {
+    product: {
+        slug: string;
+        name: string;
+    };
+    price: {
+        amount: number;
+        currency: string;
+        interval: string | null;
+    } | null;
+    returnUrl: string | null;
+}
+
+type ExportJsonValue = string | number | boolean | null | ExportJsonValue[] | {
+    [key: string]: ExportJsonValue;
+};
+interface CustomerDataExport {
+    generatedAt: string;
+    customer: {
+        id: string;
+        externalId: string;
+        name: string | null;
+        email: string | null;
+        phone: string | null;
+        taxId: string | null;
+        createdAt: string;
+        updatedAt: string;
+    };
+    paymentMethods: Array<{
+        id: string;
+        provider: string;
+        brand: string | null;
+        last4: string | null;
+        expMonth: number | null;
+        expYear: number | null;
+        isDefault: boolean;
+        status: PaymentMethodStatus;
+        createdAt: string;
+    }>;
+    subscriptions: Array<{
+        id: string;
+        customerId: string;
+        productVersionId: string;
+        currency: string;
+        status: string;
+        currentPeriodStart: string | null;
+        currentPeriodEnd: string | null;
+        trialEnd: string | null;
+        cancelAtPeriodEnd: boolean;
+        canceledAt: string | null;
+        scheduledChange: ExportJsonValue | null;
+        createdAt: string;
+        updatedAt: string;
+    }>;
+    subscriptionItems: Array<{
+        id: string;
+        subscriptionId: string;
+        priceId: string;
+        quantity: number;
+        createdAt: string;
+        updatedAt: string;
+    }>;
+    discounts: Array<{
+        id: string;
+        subscriptionId: string;
+        couponId: string;
+        cyclesRemaining: number | null;
+        createdAt: string;
+        updatedAt: string;
+    }>;
+    invoices: Array<{
+        id: string;
+        customerId: string;
+        subscriptionId: string | null;
+        number: string | null;
+        status: InvoiceStatus;
+        subtotal: number;
+        discountTotal: number;
+        usageTotal: number;
+        taxTotal: number;
+        total: number;
+        currency: string;
+        periodStart: string | null;
+        periodEnd: string | null;
+        createdAt: string;
+        updatedAt: string;
+    }>;
+    invoiceLineItems: Array<{
+        id: string;
+        invoiceId: string;
+        type: string;
+        description: string | null;
+        amount: number;
+        quantity: number;
+        currency: string;
+        createdAt: string;
+        updatedAt: string;
+    }>;
+    charges: Array<{
+        id: string;
+        invoiceId: string | null;
+        paymentMethodId: string | null;
+        kind: string;
+        subtotal: number;
+        tax: number;
+        amount: number;
+        currency: string;
+        provider: string;
+        receiptNumber: string | null;
+        status: ChargeStatus;
+        disputedAt: string | null;
+        disputeReason: string | null;
+        disputeAmount: number | null;
+        createdAt: string;
+        updatedAt: string;
+    }>;
+    refunds: Array<{
+        id: string;
+        chargeId: string;
+        amount: number;
+        subtotal: number;
+        tax: number;
+        currency: string;
+        status: RefundStatus;
+        providerRefundId: string | null;
+        creditNoteNumber: string | null;
+        createdAt: string;
+        updatedAt: string;
+    }>;
+    usageEvents: Array<{
+        id: string;
+        featureId: string;
+        value: number;
+        properties: ExportJsonValue;
+        occurredAt: string;
+        createdAt: string;
+    }>;
+    /** The customer's prepaid credits. Every credit quantity is a decimal string of microcredits. */
+    credits: CustomerCreditsExport;
+}
+/** A customer's prepaid credits in the data export; empty when they never had a credit account. */
+interface CustomerCreditsExport {
+    account: {
+        id: string;
+        status: "active" | "frozen" | "closed";
+        /** The grants' unheld credits, as the ledger has them. */
+        available: string;
+        /** What can be spent now: `available` less credits already past their expiry. */
+        spendable: string;
+        held: string;
+        /** The threshold level the account's last balance change left it at. */
+        thresholdLevel: CreditThresholdLevel;
+        createdAt: string;
+        updatedAt: string;
+    } | null;
+    grants: CreditGrant[];
+    reservations: Array<{
+        id: string;
+        /** The customer's external id. */
+        customerId: string;
+        operationKey: string;
+        category: string;
+        amount: string;
+        consumed: string;
+        status: "held" | "protected" | "committed" | "released" | "expired";
+        expiresAt: string;
+        protectedAt: string | null;
+        settledAt: string | null;
+        /** The commit's `consume` ledger transaction. */
+        consumptionId: string | null;
+        metadata: Record<string, string> | null;
+        createdAt: string;
+    }>;
+    /** Every credit top-up, as it now stands. */
+    topUps: CreditTopUp[];
+    /** Every consumption reversal, with your own reason and metadata (cleared on erasure). */
+    reversals: Array<{
+        id: string;
+        /** The customer's external id. */
+        customerId: string;
+        /** The consumption reversed: its commit's `consume` ledger transaction. */
+        consumptionId: string;
+        /** The `reverse` ledger transaction. */
+        transactionId: string;
+        amount: string;
+        /** Of `amount`, what came back to an expired grant and expired again at once. */
+        forfeited: string;
+        reason: string | null;
+        metadata: Record<string, string> | null;
+        createdAt: string;
+    }>;
+    /** Every ledger transaction, in the order it was written, with its postings. */
+    ledger: Array<{
+        id: string;
+        type: "grant" | "hold" | "release" | "consume" | "expire" | "reverse" | "revoke" | "adjust";
+        grantId: string | null;
+        reservationId: string | null;
+        topUpId: string | null;
+        consumptionId: string | null;
+        reason: string | null;
+        availableAfter: string;
+        heldAfter: string;
+        createdAt: string;
+        postings: Array<{
+            grantId: string | null;
+            bucket: "available" | "held" | "issued" | "consumed" | "expired";
+            amount: string;
+        }>;
+        consumptionItems: Array<{
+            action: string;
+            category: string;
+            units: string;
+            amount: string;
+            rateCardVersion: number | null;
+            dimensions: ExportJsonValue;
+        }>;
+    }>;
+}
+interface CustomerAnonymizationResult {
+    id: string;
+    anonymizedAt: string;
+    retainedRecords: string[];
+}
+
+/** Public SDK types for refunds and their review. Re-exported by ../types.ts. */
+
+/**
+ * Why a refund waits for an Operator:
+ * - `unconfirmed`: the provider never confirmed it within its reconcile attempts;
+ * - `unconfirmable_without_provider_id`: the provider's answer to the refund request was lost
+ *   before it returned a refund id, and the provider can find a refund only by that id (Paymob),
+ *   so nothing Billow can ask it would confirm this request;
+ * - `provider_conflict`: the provider answered against this refund's recorded outcome;
+ * - `conflict_on_charge`: another refund of the charge has an unresolved provider conflict.
+ */
+type RefundReviewReason = "unconfirmed" | "unconfirmable_without_provider_id" | "provider_conflict" | "conflict_on_charge";
+interface Refund {
+    id: string;
+    chargeId: string;
+    amount: number;
+    subtotal: number;
+    tax: number;
+    currency: string;
+    /**
+     * `pending` while the provider is settling it or its answer was lost (the amount stays
+     * reserved and further refunds of the charge are refused until it settles).
+     */
+    status: RefundStatus;
+    /**
+     * Billow cannot settle this refund on its own (`reviewReason` says why): check the provider
+     * dashboard, then `charges.recheckRefund` or `charges.resolveRefund` it.
+     */
+    needsReview: boolean;
+    /** Why it needs (or needed) review - see `RefundReviewReason`. */
+    reviewReason: RefundReviewReason | null;
+    providerRefundId: string | null;
+    creditNoteNumber: string | null;
+    /**
+     * Set while the provider's own answer, which arrived after the refund was already settled the
+     * other way (e.g. `succeeded` for a refund resolved as not refunded), is unresolved: the money
+     * moved differently from what `status` says. The charge is held (no new refunds) until it is
+     * resolved as refunded with `charges.resolveRefund`, which clears it.
+     */
+    providerConflictStatus: RefundStatus | null;
+    /** When that contrary answer arrived (kept after the conflict is resolved). */
+    providerConflictAt: string | null;
+    /** The note recorded when an Operator resolved the refund by hand, else null. */
+    resolutionNote: string | null;
+    /** The API key that recorded the manual resolution, else null. */
+    resolvedBy: string | null;
+    resolvedAt: string | null;
+    createdAt: string;
+}
+/** A refund of a succeeded charge. */
+interface RefundChargeInput {
+    /** Minor units to refund (a partial); omit to refund the charge's whole remaining balance. */
+    amount?: number;
+}
+/** What `charges.refund` answers: the refund its idempotency key stands for. */
+interface RefundRequestResult extends Refund {
+    /**
+     * `true` when the idempotency key was already used: this is the refund that earlier request
+     * made, as it stands now, and nothing new was refunded. `false` when this call made it.
+     */
+    replayed: boolean;
+}
+/** The outcome an Operator verified in the provider dashboard for a refund awaiting review. */
+interface ResolveRefundInput {
+    /** `succeeded`: the provider refunded it. `failed`: no refund exists at the provider. */
+    outcome: "succeeded" | "failed";
+    /** Required. What was checked, e.g. the provider's refund reference. */
+    note: string;
+}
+
+/** Public SDK types for this domain. Re-exported by ../types.ts. */
+
+/** A registered developer webhook endpoint. The signing secret is never listed. */
+interface WebhookEndpoint {
+    id: string;
+    url: string;
+    enabled: boolean;
+    /** Subscribed event types, or `["*"]` for all. */
+    eventTypes: string[];
+    /**
+     * When billow auto-disabled this endpoint after repeated delivery failures, else
+     * null. Re-enabling it (set `enabled: true`) clears this and resumes delivery.
+     */
+    disabledAt: string | null;
+    /** Human-readable reason it was auto-disabled, else null. */
+    disabledReason: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+/** Returned once at create/rotate — carries the plaintext signing secret. */
+interface WebhookEndpointWithSecret extends WebhookEndpoint {
+    /** The HMAC signing secret — shown exactly once. Store it now; it is never listed again. */
+    secret: string;
+}
+interface CreateWebhookEndpointInput {
+    url: string;
+    /** Defaults to all events (`["*"]`). */
+    eventTypes?: string[];
+    enabled?: boolean;
+}
+interface UpdateWebhookEndpointInput {
+    url?: string;
+    eventTypes?: string[];
+    enabled?: boolean;
+}
+/** One recorded delivery attempt of an event to an endpoint. */
+interface WebhookDelivery {
+    id: string;
+    /** The event envelope id this attempt delivered. */
+    eventId: string;
+    /** "delivered" once a 2xx was received, else "failed". */
+    status: WebhookDeliveryStatus;
+    attempts: number;
+    /** HTTP status of the last attempt, or null if the request never completed. */
+    lastResponseStatus: number | null;
+    lastError: string | null;
+    deliveredAt: string | null;
+    createdAt: string;
+}
+
+declare class BillowApiError extends Error {
+    readonly status: number;
+    /**
+     * A known {@link BillowErrorCode} (widened to `string` so a newer server's code still type-checks),
+     * or one the SDK raises itself: `invalid_response` for a success (2xx other than 204) whose body
+     * was empty or could not be read or parsed. The request reached billow and was answered, but what
+     * it answered is unknown - for a write, treat the outcome as UNKNOWN (retry it under the same
+     * idempotency key), never as done or as refused.
+     */
+    readonly code: BillowErrorCode | (string & {});
+    /** Structured error context from the server (e.g. per-field validation issues), when present. */
+    readonly details?: unknown;
+    /** billow's per-request id (`x-request-id`) — quote it in a bug report to trace the server log. */
+    readonly requestId?: string | undefined;
+    constructor(status: number, code: BillowErrorCode | (string & {}), message: string, details?: unknown, requestId?: string);
+}
+/** Everything a request needs: the transport, the base URL, the bearer, and resilience knobs. */
+interface RequestContext {
+    fetch: typeof fetch;
+    baseUrl: string;
+    /** The bearer — a secret/publishable API key, or a portal-session token. */
+    bearer: string;
+    timeoutMs: number;
+    maxRetries: number;
+    retryBackoffMs: number;
+}
+
+/**
+ * Money helpers, mirrored for the SDK (which cannot import the server-side `@billow/core`).
+ * billow stores every amount as integer minor units (e.g. piasters) plus an ISO-4217 currency;
+ * the number of minor units in one major unit depends on the currency's exponent, which is NOT
+ * always 2 (KWD/BHD/OMR are 3, JPY/KRW are 0). Use these instead of a hardcoded `* 100` / `/ 100`,
+ * which silently mis-handles those currencies 10-100x.
+ *
+ * The exponent table mirrors `@billow/core` and is parity-tested against it (see money.test.ts),
+ * so a change in core fails CI until this mirror matches.
+ */
+/** The number of digits after the decimal point for `currency` (ISO-4217); defaults to 2. */
+declare function currencyExponent(currency: string): number;
+/**
+ * Convert a major-unit amount (e.g. `5.00`) into integer minor units for `currency`, rounded to
+ * the nearest minor unit. Use when building an amount to send to the API.
+ */
+declare function toMinorUnits(major: number, currency: string): number;
+/** Convert integer minor units back to major units for `currency` (the inverse of toMinorUnits). */
+declare function toMajorUnits(minor: number, currency: string): number;
+/**
+ * Format integer minor units with their currency for display (e.g. 10000, "EGP" → "EGP 100.00";
+ * 5000, "KWD" → "KWD 5.000"). The currency's exponent drives both the divisor and the decimals.
+ */
+declare function formatMoney(minor: number, currency: string): string;
+
+declare function createChargesResource(ctx: RequestContext): {
+    /** Create a customer-present charge -> returns a hosted checkout URL. Pass an
+     *  `idempotencyKey` to make the create safe to retry (with `maxRetries`). */
+    create: (input: CreateChargeInput, options?: RequestOptions) => Promise<Charge>;
+    /** Charge the customer's current saved card without customer presence. */
+    createMerchantInitiated: (input: CreateMerchantInitiatedChargeInput, options: IdempotentRequestOptions) => Promise<Charge>;
+    /** Fetch a charge. Pass `{ sync: true }` to force an authoritative provider pull. */
+    get: (id: string, opts?: {
+        sync?: boolean;
+    } & CallOptions) => Promise<Charge>;
+    /** List charges (paginated). Filters: status, currency, customer (external id), from, to. */
+    list: (params?: ChargeListParams, options?: CallOptions) => ListPromise<ChargeListItem>;
+    /** Download the one-off charge's receipt as a PDF (raw bytes). */
+    receipt: (id: string, options?: CallOptions) => Promise<ArrayBuffer>;
+    /** Download the immutable credit note for a succeeded refund. */
+    creditNote: (chargeId: string, refundId: string, options?: CallOptions) => Promise<ArrayBuffer>;
+    /**
+     * Refund a succeeded charge: `{ amount }` (minor units) for a partial, `{}` for its whole
+     * remaining balance. The `idempotencyKey` is required and must identify this one refund
+     * (e.g. your own refund request's id): a retry under it - yours, or the SDK's own
+     * `maxRetries` - answers the same refund, in whatever status, instead of refunding again.
+     * Reuse the key whenever the outcome is unknown (a timeout or dropped connection); a new
+     * key asks for a new refund, e.g. after this one `failed`. `replayed` tells the refund an
+     * earlier request under the key made (`true`) from one this call made (`false`).
+     *
+     * Always check `status`: resolving does not mean refunded. A provider that declines the
+     * refund answers `502 provider_error`, which throws with `maxRetries: 0` (the default); with
+     * `maxRetries > 0` the SDK retries that 502 under the same key, so the call resolves instead
+     * with the declined refund replayed: `status: "failed"`, `replayed: true`.
+     */
+    refund: (chargeId: string, input: RefundChargeInput, options: IdempotentRequestOptions) => Promise<RefundRequestResult>;
+    /** A charge's refunds, newest first (`needsReview` flags one awaiting an Operator). */
+    listRefunds: (chargeId: string, options?: CallOptions) => Promise<{
+        data: Refund[];
+    }>;
+    /** Reconcile a pending refund with the provider now; resolves to the refund as it stands. */
+    recheckRefund: (chargeId: string, refundId: string, options?: CallOptions) => Promise<Refund>;
+    /**
+     * Record the outcome you verified in the provider dashboard for a refund awaiting review
+     * (`needsReview`): `succeeded` settles it with a credit note, `failed` releases its amount.
+     * A refund with a provider conflict (`providerConflictStatus`) resolves only as `succeeded`.
+     */
+    resolveRefund: (chargeId: string, refundId: string, input: ResolveRefundInput, options?: CallOptions) => Promise<Refund>;
+};
+declare function createCheckoutMethodsResource(ctx: RequestContext): {
+    /** The customer-present methods + fees offered for a currency (for a method picker). */
+    list: (params: {
+        currency: string;
+    }, options?: CallOptions) => Promise<{
+        methods: CheckoutMethodInfo[];
+    }>;
+};
+
+declare function createCreditsResource(ctx: RequestContext): {
+    grants: {
+        /**
+         * Grant prepaid credits to a Customer. The `idempotencyKey` is required and must identify
+         * this one grant (e.g. your own promotion or support-ticket id): a retry under it - yours,
+         * or the SDK's own `maxRetries` - answers the same grant instead of granting twice, with
+         * `replayed: true`. Reusing the key for a different grant throws `idempotency_conflict`
+         * (409). Credit quantities are decimal strings of microcredits in both directions.
+         */
+        create: (input: CreateCreditGrantInput, options: IdempotentRequestOptions) => Promise<CreditGrantRequestResult>;
+    };
+    packs: {
+        /**
+         * The Credit Packs a customer can buy in `currency` (ISO 4217), cheapest first: credits and
+         * bonus (decimal strings of microcredits), price (minor units), and the derived
+         * `pricePerCredit` and `savingsBps` - so your pricing page never hardcodes a price.
+         */
+        list: (currency: string, options?: CallOptions) => Promise<CreditPacks>;
+        /** Configure a Credit Pack on a one-time catalog Price. */
+        create: (input: CreateCreditPackInput, options?: CallOptions) => Promise<CreditPack>;
+        /** A Credit Pack's configuration, archived or not. */
+        get: (packId: string, options?: CallOptions) => Promise<CreditPack>;
+        /** Edit a pack's terms or Price, or archive it; top-ups already made keep their terms. */
+        update: (packId: string, input: UpdateCreditPackInput, options?: CallOptions) => Promise<CreditPack>;
+    };
+    topUps: {
+        /**
+         * Buy a Credit Pack for a customer: answers the top-up with `checkoutUrl`, the hosted
+         * checkout to send the buyer to. Credits are granted when the payment succeeds (listen for
+         * `credit_top_up.succeeded`). The `idempotencyKey` is required and must identify this one
+         * purchase: a retry under it answers the same top-up as it now stands (`replayed: true`) and
+         * buys nothing again; reusing it for another purchase throws `idempotency_conflict` (409).
+         * A retry can also throw `conflict` (409), with `details.reason`: `checkout_in_progress` -
+         * the first request is still opening the checkout, so retry the same key shortly - or
+         * `checkout_unavailable` - its checkout could not be opened and never will be, so buy again
+         * under a new key.
+         */
+        create: (input: CreateCreditTopUpInput, options: IdempotentRequestOptions) => Promise<CreditTopUpRequestResult>;
+        /** A top-up as it now stands: status, checkout, grants, and what refunds revoked. */
+        get: (topUpId: string, options?: CallOptions) => Promise<CreditTopUp>;
+        /**
+         * A customer's top-ups (by external id), newest first, optionally of one status.
+         * Auto-paginating by cursor: `await` the first page, `for await (…)` every top-up, or
+         * `.listAll()` to collect them.
+         */
+        list: (customer: string, params?: CreditTopUpListParams, options?: CallOptions) => CursorListPromise<CreditTopUp>;
+    };
+    balance: {
+        /**
+         * A Customer's credit balance (by external id): spendable, held, consumed this period,
+         * expiring soon, by kind and category, the current period and the threshold level, true at
+         * `asOf`. A Customer with no credit account yet reads as zeros.
+         */
+        get: (customer: string, options?: CallOptions) => Promise<CreditBalance>;
+    };
+    ledger: {
+        /**
+         * A Customer's credit ledger (by external id), newest first. Auto-paginating by cursor:
+         * `await` the first page, `for await (…)` every entry, or `.listAll()` to collect them -
+         * entries arriving meanwhile never make the walk skip or repeat one.
+         */
+        list: (customer: string, params?: CursorListParams, options?: CallOptions) => CursorListPromise<CreditLedgerEntry>;
+    };
+    usage: {
+        /**
+         * A Customer's credit consumption (by external id) per UTC day, by Credit Action or
+         * category, over at most 92 days (the 30 ending today by default).
+         */
+        get: (customer: string, params?: CreditUsageParams, options?: CallOptions) => Promise<CreditUsage>;
+    };
+};
+
+declare function createCustomersResource(ctx: RequestContext): {
+    create: (input: {
+        id: string;
+        name?: string;
+        email?: string;
+        phone?: string;
+        /** The customer's tax / VAT registration number, recorded on their invoices. */
+        taxId?: string;
+    }) => Promise<Customer>;
+    get: (externalId: string, options?: CallOptions) => Promise<Customer>;
+    /** List customers (`q` searches external id / email / name). Auto-paginating: `await` the
+     *  first page, `for await (…)` every page, or `.listAll()` to collect them. */
+    list: (params?: CustomerListParams, options?: CallOptions) => ListPromise<CustomerListItem>;
+    /** Full per-customer view: profile + subscriptions + charges + cards + balances. */
+    overview: (externalId: string, options?: CallOptions) => Promise<CustomerOverview>;
+    paymentMethods: {
+        list: (customer: string, options?: CallOptions) => Promise<{
+            id: string;
+            brand: string | null;
+            last4: string | null;
+            expMonth: number | null;
+            expYear: number | null;
+            isDefault: boolean;
+            status: "active" | "expired" | "removed";
+            createdAt: string;
+            expiryStatus: "expired" | "unknown" | "valid" | "expiring";
+            canSetDefault: boolean;
+            canRemove: boolean;
+            removalBlockedReason: string | null;
+        }[]>;
+        setDefault: (customer: string, id: string) => Promise<{
+            id: string;
+            brand: string | null;
+            last4: string | null;
+            expMonth: number | null;
+            expYear: number | null;
+            isDefault: boolean;
+            status: "active" | "expired" | "removed";
+            createdAt: string;
+            expiryStatus: "expired" | "unknown" | "valid" | "expiring";
+            canSetDefault: boolean;
+            canRemove: boolean;
+            removalBlockedReason: string | null;
+        }>;
+        remove: (customer: string, id: string) => Promise<{
+            removed: boolean;
+        }>;
+    };
+    /** Export all portable customer data held by Billow. Secret-key only. */
+    exportData: (externalId: string, options?: CallOptions) => Promise<CustomerDataExport>;
+    /** Anonymize PII after access-granting subscriptions have ended. Secret-key only. */
+    anonymize: (externalId: string, options?: CallOptions) => Promise<CustomerAnonymizationResult>;
+};
+
+/**
+ * Delivery-failure visibility: the transactional emails and outbound events that
+ * didn't get through. Read-only, tenant-scoped to the key's (project, environment).
+ */
+declare function createDeliverabilityResource(ctx: RequestContext): {
+    /** Email deliveries (newest first), optionally filtered by status. Auto-paginating. */
+    emails: (params?: EmailDeliveryListParams, options?: CallOptions) => ListPromise<EmailDeliveryListItem>;
+    /** Outbound events (newest first), optionally filtered by status. Auto-paginating. */
+    events: (params?: OutboxEventListParams, options?: CallOptions) => ListPromise<OutboxEventListItem>;
+    /** Inbound provider webhooks (newest first), optionally filtered by outcome. Auto-paginating. */
+    inbound: (params?: InboundWebhookListParams, options?: CallOptions) => ListPromise<InboundWebhookListItem>;
+};
+
+declare function createInvoicesResource(ctx: RequestContext): {
+    /** List invoices. Filters: status, customer (external id), from, to. Auto-paginating. */
+    list: (params?: InvoiceListParams, options?: CallOptions) => ListPromise<InvoiceListItem>;
+    /** Fetch an invoice with its line items. */
+    get: (id: string, options?: CallOptions) => Promise<InvoiceDetail>;
+    /**
+     * Record that an open invoice was paid outside the gateway (bank transfer, cash, cheque).
+     * Settles the invoice and advances the subscription exactly like a gateway payment.
+     * `amount` must equal the invoice total. Operator (secret key) only.
+     */
+    recordPayment: (id: string, input: RecordExternalPaymentInput) => Promise<ExternalPaymentResult>;
+    /** Open or resume hosted checkout for an existing outstanding invoice. */
+    pay: (id: string, input?: PayInvoiceInput, options?: CallOptions) => Promise<{
+        invoiceId: string;
+        chargeId: string;
+        checkoutUrl: string;
+        status: "failed" | "processing";
+        expiresAt: string;
+    }>;
+    /** Download the invoice as a PDF (raw bytes). */
+    pdf: (id: string, options?: CallOptions) => Promise<ArrayBuffer>;
+    /** Download the invoice's payment receipt as a PDF (raw bytes; 404 if unpaid). */
+    receipt: (id: string, options?: CallOptions) => Promise<ArrayBuffer>;
+};
+
+/** The marketplace Integration catalog — install / configure / toggle / uninstall (ADR-0008). */
+declare function createMarketplaceResource(ctx: RequestContext): {
+    /** Every available Integration with this tenant's install state (no secret values). */
+    catalog: (options?: CallOptions) => Promise<CatalogItem[]>;
+    /** One catalog entry by slug. */
+    get: (slug: string, options?: CallOptions) => Promise<CatalogItem>;
+    /** Install or reconfigure an Integration; `values` are the manifest form's field values. */
+    upsert: (slug: string, values: Record<string, unknown>) => Promise<CatalogItem>;
+    /** Enable or disable an installed Integration. */
+    setEnabled: (slug: string, enabled: boolean) => Promise<CatalogItem>;
+    /** Uninstall an Integration. */
+    remove: (slug: string) => Promise<{
+        removed: boolean;
+    }>;
+    /**
+     * Verify an installed Integration's config. An email Integration sends a test
+     * message to `to` (returns `{ sent, to }`); an accounting Integration runs a
+     * non-mutating connectivity check with no recipient (returns `{ ok: true }`).
+     */
+    test: (slug: string, to?: string) => Promise<{
+        sent: boolean;
+        to: string;
+    } | {
+        ok: true;
+    }>;
+};
+
+declare function createMetricsResource(ctx: RequestContext): {
+    /** KPI cards for a currency over a window (`from`/`to` default to the last 30 days). */
+    overview: (params?: MetricsParams, options?: CallOptions) => Promise<MetricsOverview>;
+    /** A single bucketed metric (revenue / mrr / subs / success rate) over a window. */
+    timeseries: (params?: TimeseriesParams, options?: CallOptions) => Promise<TimeseriesResult>;
+    /**
+     * KPIs rolled up into the org's reporting currency across all billing currencies
+     * (Phase H). Resolves to `null` when no reporting currency is configured.
+     */
+    rollup: (params?: {
+        from?: string;
+        to?: string;
+    }, options?: CallOptions) => Promise<MetricsRollup | null>;
+};
+
+declare function createPortalSessionsResource(ctx: RequestContext): {
+    create: (input: CreatePortalSessionInput) => Promise<PortalSession>;
+};
+
+declare function createProductsResource(ctx: RequestContext): {
+    /** Define a product (its first active version + prices + entitlements). */
+    create: (input: CreateProductInput) => Promise<{
+        id: string;
+        slug: string;
+        name: string;
+        type: "recurring" | "one_time";
+        isAddOn: boolean;
+        metadata: Record<string, string>;
+        version: number;
+        archived: boolean;
+        prices: {
+            id: string;
+            kind: "one_time" | "fixed_recurring" | "licensed" | "usage";
+            interval: "day" | "week" | "month" | "year" | null;
+            intervalCount: number;
+            amount: number;
+            currency: string;
+            meterFeature: string | null;
+            usageModel: "graduated" | "volume" | "package" | "percentage" | "stairstep" | null;
+            usageTiers: {
+                upTo: number | null;
+                unitAmount: number;
+                flatAmount?: number | undefined;
+            }[] | null;
+            packageSize: number | null;
+            rateBps: number | null;
+            taxRateBps: number | null;
+            taxBehavior: "inclusive" | "exclusive" | null;
+        }[];
+        entitlements: {
+            feature: string;
+            allowance: number | null;
+            resetInterval: "day" | "week" | "month" | "year" | null;
+            rollover: boolean;
+        }[];
+    }>;
+    /**
+     * Update a product: rename, archive/unarchive, and/or edit its prices +
+     * entitlements in place.
+     */
+    update: (slug: string, input: UpdateProductInput) => Promise<{
+        id: string;
+        slug: string;
+        name: string;
+        type: "recurring" | "one_time";
+        isAddOn: boolean;
+        metadata: Record<string, string>;
+        version: number;
+        archived: boolean;
+        prices: {
+            id: string;
+            kind: "one_time" | "fixed_recurring" | "licensed" | "usage";
+            interval: "day" | "week" | "month" | "year" | null;
+            intervalCount: number;
+            amount: number;
+            currency: string;
+            meterFeature: string | null;
+            usageModel: "graduated" | "volume" | "package" | "percentage" | "stairstep" | null;
+            usageTiers: {
+                upTo: number | null;
+                unitAmount: number;
+                flatAmount?: number | undefined;
+            }[] | null;
+            packageSize: number | null;
+            rateBps: number | null;
+            taxRateBps: number | null;
+            taxBehavior: "inclusive" | "exclusive" | null;
+        }[];
+        entitlements: {
+            feature: string;
+            allowance: number | null;
+            resetInterval: "day" | "week" | "month" | "year" | null;
+            rollover: boolean;
+        }[];
+    }>;
+    /** Fetch a product (active version + prices + entitlements) by slug. */
+    get: (slug: string, options?: CallOptions) => Promise<{
+        id: string;
+        slug: string;
+        name: string;
+        type: "recurring" | "one_time";
+        isAddOn: boolean;
+        metadata: Record<string, string>;
+        version: number;
+        archived: boolean;
+        prices: {
+            id: string;
+            kind: "one_time" | "fixed_recurring" | "licensed" | "usage";
+            interval: "day" | "week" | "month" | "year" | null;
+            intervalCount: number;
+            amount: number;
+            currency: string;
+            meterFeature: string | null;
+            usageModel: "graduated" | "volume" | "package" | "percentage" | "stairstep" | null;
+            usageTiers: {
+                upTo: number | null;
+                unitAmount: number;
+                flatAmount?: number | undefined;
+            }[] | null;
+            packageSize: number | null;
+            rateBps: number | null;
+            taxRateBps: number | null;
+            taxBehavior: "inclusive" | "exclusive" | null;
+        }[];
+        entitlements: {
+            feature: string;
+            allowance: number | null;
+            resetInterval: "day" | "week" | "month" | "year" | null;
+            rollover: boolean;
+        }[];
+    }>;
+    /** List products. `includeArchived` also returns archived ones (for admin views). */
+    list: (params?: {
+        includeArchived?: boolean;
+    }, options?: CallOptions) => Promise<{
+        id: string;
+        slug: string;
+        name: string;
+        type: "recurring" | "one_time";
+        isAddOn: boolean;
+        metadata: Record<string, string>;
+        version: number;
+        archived: boolean;
+        prices: {
+            id: string;
+            kind: "one_time" | "fixed_recurring" | "licensed" | "usage";
+            interval: "day" | "week" | "month" | "year" | null;
+            intervalCount: number;
+            amount: number;
+            currency: string;
+            meterFeature: string | null;
+            usageModel: "graduated" | "volume" | "package" | "percentage" | "stairstep" | null;
+            usageTiers: {
+                upTo: number | null;
+                unitAmount: number;
+                flatAmount?: number | undefined;
+            }[] | null;
+            packageSize: number | null;
+            rateBps: number | null;
+            taxRateBps: number | null;
+            taxBehavior: "inclusive" | "exclusive" | null;
+        }[];
+        entitlements: {
+            feature: string;
+            allowance: number | null;
+            resetInterval: "day" | "week" | "month" | "year" | null;
+            rollover: boolean;
+        }[];
+    }[]>;
+    /** Delete a plan (soft-delete, ADR-0015). */
+    delete: (slug: string) => Promise<void>;
+    /** Migrate every live subscriber of `fromSlug` onto `toSlug`. */
+    migrateSubscribers: (fromSlug: string, toSlug: string) => Promise<MigrationResult>;
+    /** Live-subscriber count per product, keyed by product id. */
+    subscriberCounts: (options?: CallOptions) => Promise<Record<string, number>>;
+};
+
+/**
+ * Organization settings (Phase D3, F) — the configurable dunning schedule, usage settlement grace,
+ * the cross-currency reporting currency + FX-rate registry (ADR-0013), and transactional email
+ * template overrides (PRD-10). All secret-key/server-side surface.
+ */
+declare function createSettingsResource(ctx: RequestContext): {
+    /** The dunning retry schedule: configured gaps in days (null = default), + the default. */
+    dunning: {
+        get: (options?: CallOptions) => Promise<{
+            retryDays: number[] | null;
+            defaultRetryDays: number[];
+        }>;
+        /** Set the retry gaps (whole days); pass `null`/`[]` to reset to the default. */
+        update: (retryDays: number[] | null) => Promise<{
+            retryDays: number[] | null;
+            defaultRetryDays: number[];
+        }>;
+    };
+    /**
+     * Usage settlement grace (hours): defers *collection* of a boundary-adjacent priced
+     * calendar-meter renewal past the tz month boundary until late usage settles — the billed
+     * windows/amount are unchanged, only the invoice timing shifts. `0` disables it (the default);
+     * a no-op for any subscription without a priced calendar meter. Cap 72h.
+     */
+    usageSettlementGrace: {
+        get: (options?: CallOptions) => Promise<{
+            graceHours: number;
+        }>;
+        /** Set the grace window in whole hours (0–72); `0` disables. */
+        update: (graceHours: number) => Promise<{
+            graceHours: number;
+        }>;
+    };
+    /** The currency cross-currency reporting rolls up into (null = none configured). */
+    reporting: {
+        get: (options?: CallOptions) => Promise<{
+            reportingCurrency: string | null;
+        }>;
+        /** Set the reporting currency (3-letter ISO), or `null` to clear it. */
+        update: (currency: string | null) => Promise<{
+            reportingCurrency: string | null;
+        }>;
+    };
+    /** The manually-maintained FX rates the per-invoice reporting snapshot draws on. */
+    fxRates: {
+        list: (options?: CallOptions) => Promise<ExchangeRate[]>;
+        /** Upsert one `base → quote` rate (`rate` is the decimal quote-per-base, > 0). */
+        set: (baseCurrency: string, quoteCurrency: string, rate: number) => Promise<ExchangeRate>;
+        /** Remove a `base → quote` rate. */
+        remove: (baseCurrency: string, quoteCurrency: string) => Promise<{
+            removed: boolean;
+        }>;
+    };
+    /** Transactional email templates (PRD-10): per-template subject/message overrides. */
+    emailTemplates: {
+        /** Every template, merged with this project's overrides, in display order. */
+        list: (options?: CallOptions) => Promise<EmailTemplateSetting[]>;
+        /** Update one template's override (validated against its variable allowlist). */
+        update: (key: string, input: UpdateEmailTemplateInput) => Promise<EmailTemplateSetting>;
+        /**
+         * Send a `[Test]`-prefixed sample of one template to `to`. Dashboard-only:
+         * the API rejects developer keys (the dashboard restricts the recipient to
+         * the signed-in operator; a developer key has no such guarantee).
+         */
+        test: (key: string, to: string) => Promise<{
+            sent: boolean;
+            to: string;
+        }>;
+    };
+};
+
+declare function createSubscriptionsResource(ctx: RequestContext): {
+    /** Start a subscription -> returns the subscription plus a hosted checkout URL. `productId`
+     *  accepts the product's id or slug. Pass an `idempotencyKey` to make it safe to retry. */
+    create: (input: CreateSubscriptionInput, options?: RequestOptions) => Promise<{
+        id: string;
+        status: "active" | "incomplete" | "incomplete_expired" | "trialing" | "past_due" | "paused" | "canceled" | "unpaid";
+        customerId: string;
+        productVersionId: string;
+        currency: string;
+        currentPeriodStart: string | null;
+        currentPeriodEnd: string | null;
+        trialEnd: string | null;
+        cancelAtPeriodEnd: boolean;
+        scheduledChange: {
+            productVersionId: string;
+            productId: string;
+            productSlug: string;
+            productName: string;
+            effectiveAt: string | null;
+        } | null;
+        canceledAt: string | null;
+        remainingCycles: number | null;
+        defaultPaymentMethodId: string | null;
+        createdAt: string;
+        subscriptionId: string;
+        checkoutSessionId: string | null;
+        invoiceId: string | null;
+        checkoutUrl: string | null;
+    } | {
+        id: null;
+        subscriptionId: null;
+        checkoutSessionId: string | null;
+        status: string;
+        customerId: string | null;
+        productVersionId: string | null;
+        currency: string | null;
+        currentPeriodStart: null;
+        currentPeriodEnd: null;
+        trialEnd: null;
+        cancelAtPeriodEnd: false;
+        scheduledChange: null;
+        canceledAt: null;
+        remainingCycles: number | null;
+        defaultPaymentMethodId: null;
+        createdAt: string;
+        invoiceId: null;
+        checkoutUrl: string | null;
+    }>;
+    /** Grant a free comp subscription (operator action). `productId` accepts the product's id or slug. */
+    comp: (input: {
+        customerId: string;
+        productId: string;
+        currency?: string;
+    }) => Promise<{
+        id: string;
+        status: "active" | "incomplete" | "incomplete_expired" | "trialing" | "past_due" | "paused" | "canceled" | "unpaid";
+        customerId: string;
+        productVersionId: string;
+        currency: string;
+        currentPeriodStart: string | null;
+        currentPeriodEnd: string | null;
+        trialEnd: string | null;
+        cancelAtPeriodEnd: boolean;
+        scheduledChange: {
+            productVersionId: string;
+            productId: string;
+            productSlug: string;
+            productName: string;
+            effectiveAt: string | null;
+        } | null;
+        canceledAt: string | null;
+        remainingCycles: number | null;
+        defaultPaymentMethodId: string | null;
+        createdAt: string;
+        subscriptionId: string;
+        checkoutSessionId: string | null;
+        invoiceId: string | null;
+        checkoutUrl: string | null;
+    }>;
+    /** List subscriptions (paginated). Filters: status, customer (external id). */
+    list: (params?: SubscriptionListParams, options?: CallOptions) => ListPromise<SubscriptionListItem>;
+    get: (id: string, options?: CallOptions) => Promise<{
+        id: string;
+        status: "active" | "incomplete" | "incomplete_expired" | "trialing" | "past_due" | "paused" | "canceled" | "unpaid";
+        customerId: string;
+        productVersionId: string;
+        currency: string;
+        currentPeriodStart: string | null;
+        currentPeriodEnd: string | null;
+        trialEnd: string | null;
+        cancelAtPeriodEnd: boolean;
+        scheduledChange: {
+            productVersionId: string;
+            productId: string;
+            productSlug: string;
+            productName: string;
+            effectiveAt: string | null;
+        } | null;
+        canceledAt: string | null;
+        remainingCycles: number | null;
+        defaultPaymentMethodId: string | null;
+        createdAt: string;
+        customerExternalId: string;
+        productId: string;
+        productSlug: string;
+        productMetadata: Record<string, string>;
+    }>;
+    /**
+     * The single subscription that currently determines the customer's access, resolved by
+     * billow's own rule (access-granting statuses first, then newest) - or `null` if the
+     * customer has none. Prefer this over picking from `list()` yourself: it avoids the
+     * "newer failed-checkout subscription shadows an older active one" selection bug.
+     */
+    current: (params: {
+        customer: string;
+    }, options?: CallOptions) => Promise<{
+        id: string;
+        status: "active" | "incomplete" | "incomplete_expired" | "trialing" | "past_due" | "paused" | "canceled" | "unpaid";
+        customerId: string;
+        productVersionId: string;
+        currency: string;
+        currentPeriodStart: string | null;
+        currentPeriodEnd: string | null;
+        trialEnd: string | null;
+        cancelAtPeriodEnd: boolean;
+        scheduledChange: {
+            productVersionId: string;
+            productId: string;
+            productSlug: string;
+            productName: string;
+            effectiveAt: string | null;
+        } | null;
+        canceledAt: string | null;
+        remainingCycles: number | null;
+        defaultPaymentMethodId: string | null;
+        createdAt: string;
+        customerExternalId: string;
+        productId: string;
+        productSlug: string;
+        productMetadata: Record<string, string>;
+    } | null>;
+    /** Cancel — immediately, or at period end with `{ atPeriodEnd: true }`. */
+    cancel: (id: string, opts?: {
+        atPeriodEnd?: boolean;
+    }) => Promise<{
+        id: string;
+        status: "active" | "incomplete" | "incomplete_expired" | "trialing" | "past_due" | "paused" | "canceled" | "unpaid";
+        customerId: string;
+        productVersionId: string;
+        currency: string;
+        currentPeriodStart: string | null;
+        currentPeriodEnd: string | null;
+        trialEnd: string | null;
+        cancelAtPeriodEnd: boolean;
+        scheduledChange: {
+            productVersionId: string;
+            productId: string;
+            productSlug: string;
+            productName: string;
+            effectiveAt: string | null;
+        } | null;
+        canceledAt: string | null;
+        remainingCycles: number | null;
+        defaultPaymentMethodId: string | null;
+        createdAt: string;
+    }>;
+    /** Reverse a scheduled period-end cancellation. Duplicate calls are safe. */
+    resumeCancellation: (id: string) => Promise<{
+        id: string;
+        status: "active" | "incomplete" | "incomplete_expired" | "trialing" | "past_due" | "paused" | "canceled" | "unpaid";
+        customerId: string;
+        productVersionId: string;
+        currency: string;
+        currentPeriodStart: string | null;
+        currentPeriodEnd: string | null;
+        trialEnd: string | null;
+        cancelAtPeriodEnd: boolean;
+        scheduledChange: {
+            productVersionId: string;
+            productId: string;
+            productSlug: string;
+            productName: string;
+            effectiveAt: string | null;
+        } | null;
+        canceledAt: string | null;
+        remainingCycles: number | null;
+        defaultPaymentMethodId: string | null;
+        createdAt: string;
+    }>;
+    pause: (id: string) => Promise<{
+        id: string;
+        status: "active" | "incomplete" | "incomplete_expired" | "trialing" | "past_due" | "paused" | "canceled" | "unpaid";
+        customerId: string;
+        productVersionId: string;
+        currency: string;
+        currentPeriodStart: string | null;
+        currentPeriodEnd: string | null;
+        trialEnd: string | null;
+        cancelAtPeriodEnd: boolean;
+        scheduledChange: {
+            productVersionId: string;
+            productId: string;
+            productSlug: string;
+            productName: string;
+            effectiveAt: string | null;
+        } | null;
+        canceledAt: string | null;
+        remainingCycles: number | null;
+        defaultPaymentMethodId: string | null;
+        createdAt: string;
+    }>;
+    resume: (id: string) => Promise<{
+        id: string;
+        status: "active" | "incomplete" | "incomplete_expired" | "trialing" | "past_due" | "paused" | "canceled" | "unpaid";
+        customerId: string;
+        productVersionId: string;
+        currency: string;
+        currentPeriodStart: string | null;
+        currentPeriodEnd: string | null;
+        trialEnd: string | null;
+        cancelAtPeriodEnd: boolean;
+        scheduledChange: {
+            productVersionId: string;
+            productId: string;
+            productSlug: string;
+            productName: string;
+            effectiveAt: string | null;
+        } | null;
+        canceledAt: string | null;
+        remainingCycles: number | null;
+        defaultPaymentMethodId: string | null;
+        createdAt: string;
+    }>;
+    /** Apply a coupon to an existing subscription. */
+    applyCoupon: (id: string, code: string) => Promise<{
+        id: string;
+        couponId: string;
+        cyclesRemaining: number | null;
+    }>;
+    /** Change plan — immediate prorated upgrade, or downgrade scheduled for period end. `productId` accepts the product's id or slug. */
+    changePlan: (id: string, productId: string) => Promise<{
+        id: string;
+        status: "active" | "incomplete" | "incomplete_expired" | "trialing" | "past_due" | "paused" | "canceled" | "unpaid";
+        customerId: string;
+        productVersionId: string;
+        currency: string;
+        currentPeriodStart: string | null;
+        currentPeriodEnd: string | null;
+        trialEnd: string | null;
+        cancelAtPeriodEnd: boolean;
+        scheduledChange: {
+            productVersionId: string;
+            productId: string;
+            productSlug: string;
+            productName: string;
+            effectiveAt: string | null;
+        } | null;
+        canceledAt: string | null;
+        remainingCycles: number | null;
+        defaultPaymentMethodId: string | null;
+        createdAt: string;
+    } & {
+        change: "upgrade" | "downgrade" | "noop";
+        prorationInvoiceId: string | null;
+        chargeStatus: string | null;
+    }>;
+    /** Clear a pending downgrade. Duplicate calls are safe. */
+    clearScheduledPlanChange: (id: string) => Promise<{
+        id: string;
+        status: "active" | "incomplete" | "incomplete_expired" | "trialing" | "past_due" | "paused" | "canceled" | "unpaid";
+        customerId: string;
+        productVersionId: string;
+        currency: string;
+        currentPeriodStart: string | null;
+        currentPeriodEnd: string | null;
+        trialEnd: string | null;
+        cancelAtPeriodEnd: boolean;
+        scheduledChange: {
+            productVersionId: string;
+            productId: string;
+            productSlug: string;
+            productName: string;
+            effectiveAt: string | null;
+        } | null;
+        canceledAt: string | null;
+        remainingCycles: number | null;
+        defaultPaymentMethodId: string | null;
+        createdAt: string;
+    }>;
+    items: {
+        /** List a subscription's items (base + add-ons). */
+        list: (id: string, options?: CallOptions) => Promise<{
+            id: string;
+            product: string;
+            productSlug: string;
+            priceId: string;
+            kind: "one_time" | "fixed_recurring" | "licensed" | "usage";
+            amount: number;
+            currency: string;
+            quantity: number;
+            isAddOn: boolean;
+            isBase: boolean;
+        }[]>;
+        /** Attach an add-on Product. `productId` accepts the product's id or slug. */
+        add: (id: string, productId: string, quantity?: number) => Promise<{
+            id: string;
+            product: string;
+            productSlug: string;
+            priceId: string;
+            kind: "one_time" | "fixed_recurring" | "licensed" | "usage";
+            amount: number;
+            currency: string;
+            quantity: number;
+            isAddOn: boolean;
+            isBase: boolean;
+        }>;
+        /** Change an item's quantity (seats). */
+        updateQuantity: (id: string, itemId: string, quantity: number) => Promise<{
+            id: string;
+            product: string;
+            productSlug: string;
+            priceId: string;
+            kind: "one_time" | "fixed_recurring" | "licensed" | "usage";
+            amount: number;
+            currency: string;
+            quantity: number;
+            isAddOn: boolean;
+            isBase: boolean;
+        }>;
+        /** Detach an add-on item. */
+        remove: (id: string, itemId: string) => Promise<{
+            removed: boolean;
+        }>;
+    };
+};
+
+declare function createWebhookEndpointsResource(ctx: RequestContext): {
+    /** Register an endpoint. The signing secret is returned once. */
+    create: (input: CreateWebhookEndpointInput) => Promise<WebhookEndpointWithSecret>;
+    /** List endpoints (newest first; secrets are never returned). Auto-paginating. */
+    list: (params?: ListParams, options?: CallOptions) => ListPromise<WebhookEndpoint>;
+    /** Fetch one endpoint by id. */
+    get: (id: string, options?: CallOptions) => Promise<WebhookEndpoint>;
+    /** Update an endpoint's URL, enabled flag, or event filter. */
+    update: (id: string, input: UpdateWebhookEndpointInput) => Promise<WebhookEndpoint>;
+    /** Delete an endpoint and its delivery history. */
+    delete: (id: string) => Promise<void>;
+    /** Rotate the signing secret — the new plaintext is returned once. */
+    rotateSecret: (id: string) => Promise<WebhookEndpointWithSecret>;
+    /** List delivery attempts for an endpoint (newest first). Auto-paginating. */
+    deliveries: (id: string, params?: ListParams, options?: CallOptions) => ListPromise<WebhookDelivery>;
+};
+
+/**
+ * billow client SDK — the "two lines of code" surface, mirroring Autumn's shape
+ * (CONTEXT/ARCHITECTURE §10). A thin typed wrapper over the billow REST API.
+ *
+ *   const billow = new Billow(process.env.BILLOW_SECRET_KEY!);
+ *   const { allowed } = await billow.check({ customerId, featureId: "projects" });
+ *
+ * Public request/response types live in ./types and are re-exported here, so the
+ * package root stays the single import surface. They are contract-derived and inlined
+ * into the shipped .d.ts at build time (tsup `dts.resolve` reads @billow/contracts'
+ * bundled dist), so the declarations carry no bare `@billow/contracts` import a
+ * consumer couldn't resolve.
+ *
+ * We deliberately do NOT re-export @billow/contracts' runtime zod schemas: a client
+ * SDK shouldn't ship validation - the server is the schema authority - and
+ * re-exporting them made @billow/contracts (a private, unpublished workspace package)
+ * a runtime dependency that left the published SDK impossible to install. Contracts is
+ * now a devDependency. The types are zod-inferred, so the declarations do reference
+ * `zod` (a small, published package kept as a runtime dependency); the runtime bundle
+ * itself imports neither zod nor @billow/contracts.
+ */
+
+declare class Billow {
+    #private;
+    customers: ReturnType<typeof createCustomersResource>;
+    charges: ReturnType<typeof createChargesResource>;
+    checkoutMethods: ReturnType<typeof createCheckoutMethodsResource>;
+    /** Prepaid credits: grant them to a Customer (quantities are decimal strings of microcredits). */
+    credits: ReturnType<typeof createCreditsResource>;
+    invoices: ReturnType<typeof createInvoicesResource>;
+    metrics: ReturnType<typeof createMetricsResource>;
+    webhookEndpoints: ReturnType<typeof createWebhookEndpointsResource>;
+    products: ReturnType<typeof createProductsResource>;
+    subscriptions: ReturnType<typeof createSubscriptionsResource>;
+    portalSessions: ReturnType<typeof createPortalSessionsResource>;
+    deliverability: ReturnType<typeof createDeliverabilityResource>;
+    marketplace: ReturnType<typeof createMarketplaceResource>;
+    /**
+     * Organization settings (Phase D3, F) — the configurable dunning schedule, usage settlement grace,
+     * and the cross-currency reporting currency + FX-rate registry (ADR-0013).
+     */
+    settings: ReturnType<typeof createSettingsResource>;
+    constructor(apiKey: string, opts?: BillowOptions);
+    coupons: {
+        /** Define a coupon (a reusable discount template). */
+        create: (input: CreateCouponInput) => Promise<Coupon>;
+        /** List coupons (secret key only — enumerates live promo codes). Auto-paginating. */
+        list: (params?: ListParams, options?: CallOptions) => ListPromise<Coupon>;
+        /** Deactivate a coupon (existing discounts keep running). */
+        deactivate: (id: string) => Promise<Coupon>;
+    };
+    /** Manage developer webhook endpoints — register, rotate secrets, inspect deliveries.
+     *  (To VERIFY incoming deliveries, import `constructEvent` from `@usebillow/sdk/webhooks`.) */
+    features: {
+        /** Define a feature (a boolean access gate, or a metered feature with a meter). */
+        create: (input: {
+            slug: string;
+            name: string;
+            kind: FeatureKind;
+            meter?: MeterConfig;
+        }) => Promise<Feature>;
+        /**
+         * Edit a feature in place: its `name`, and — for a metered feature — its `meter`
+         * aggregation. The server refuses a meter change once usage has been recorded (it
+         * would rewrite billed history), so set the meter right at create time or before you
+         * start tracking. Returns the updated feature.
+         */
+        update: (slug: string, input: UpdateFeatureInput) => Promise<Feature>;
+        /** List features in the tenant. Auto-paginating. */
+        list: (params?: ListParams, options?: CallOptions) => ListPromise<Feature>;
+        /**
+         * Usage Alerts + Spend caps on a metered feature (Phase C). A `threshold`
+         * Alert notifies (webhook + optional customer email) as usage crosses its
+         * thresholds; a `cap` blocks `check` once reached.
+         */
+        alerts: {
+            /** List the alerts + spend cap on a metered feature (by slug). */
+            list: (feature: string, options?: CallOptions) => Promise<UsageAlert[]>;
+            /** Define an Alert or Spend cap on a metered feature. */
+            create: (feature: string, input: CreateUsageAlertInput) => Promise<UsageAlert>;
+            /** Delete one alert/cap rule by id. */
+            remove: (feature: string, id: string) => Promise<{
+                removed: boolean;
+            }>;
+        };
+    };
+    integrations: {
+        /** The registered payment providers + their config manifests (drives the picker + form). */
+        providers: (options?: CallOptions) => Promise<PaymentProviderDefinition[]>;
+        /** List configured credential sets per currency (provider + non-secret config). Secret-only. */
+        list: (options?: CallOptions) => Promise<ProviderCredentialSummary[]>;
+        /**
+         * Verify a provider's configuration against its live API. Pass `currency` to
+         * choose a credential set and `target` to probe one verify target (Paymob: a
+         * method); pass `sampleToken` (SANDBOX ONLY) to run a functional sub-test.
+         * This probe hits the provider's live API (mutates nothing here), so it takes a
+         * per-call {@link CallOptions} for a timeout / cancellation — `opts` is spread into
+         * the body, so `options` stays a separate trailing arg (never merged in).
+         */
+        verify: (provider: string, opts?: {
+            currency?: string;
+            target?: string;
+            sampleToken?: string;
+        }, options?: CallOptions) => Promise<ProviderVerifyResult>;
+        /** Manage stored payment-provider credentials (the dashboard's "manage credentials" forms). */
+        credentials: {
+            /** The editable view of stored credential sets (secrets are never returned). */
+            list: (options?: CallOptions) => Promise<CredentialSet[]>;
+            /** Create or rotate a (provider, currency) credential set. */
+            upsert: (input: UpsertCredentialsInput) => Promise<CredentialSet>;
+            /** Delete a (provider, currency) credential set. */
+            remove: (provider: string, currency: string) => Promise<{
+                removed: boolean;
+            }>;
+        };
+    };
+    /** The merchant's business identity — the seller block on documents and email from-name. */
+    businessProfile: {
+        /** The stored profile, or null if one was never saved. */
+        get: (options?: CallOptions) => Promise<BusinessProfile | null>;
+        /** Create or update the profile; omit a field to keep it, send "" to clear it. */
+        update: (input: UpdateBusinessProfileInput) => Promise<BusinessProfile>;
+    };
+    /**
+     * Hosted customer surfaces (Phase G, ADR-0014). Mint a portal session for one of
+     * your signed-in users and redirect them to the returned `url` — the self-serve
+     * portal, or a `checkout` hand-off for `productId`. The Customer's own calls go
+     * through {@link BillowPortal}, constructed with the session token.
+     */
+    /** Identity of this key's tenant — org, environment, configured currencies. */
+    me(options?: CallOptions): Promise<Whoami>;
+    /**
+     * Global search (PRD-12) across customers, invoices, subscriptions, and charges
+     * for the key's `(project, environment)`. Bounded per entity (default 5, max 10);
+     * a blank query returns empty results. Backs the dashboard's ⌘K palette.
+     */
+    search(q: string, limit?: number, options?: CallOptions): Promise<SearchResults>;
+    /**
+     * Gate access to a feature. `featureId` is the feature slug. Returns
+     * `{ allowed, balance }` — `balance` is `null` for unlimited/boolean features.
+     */
+    check(input: {
+        customerId: string;
+        featureId: string;
+    }, options?: CallOptions): Promise<CheckResult>;
+    /**
+     * Record usage of a metered feature (`value` defaults to 1; negative credits
+     * back). Pass `idempotencyKey` to make a retried call a no-op — which also makes the call
+     * safe to retry automatically when `maxRetries` is set.
+     */
+    track(input: {
+        customerId: string;
+        featureId: string;
+        value?: number;
+        /** Arbitrary event properties — used by meter filters and property-based aggregations. */
+        properties?: Record<string, string | number>;
+        idempotencyKey?: string;
+        /**
+         * When the usage occurred (ISO-8601). Defaults to now; backdate it to land a value in a
+         * still-open reset window (e.g. a finalized month-end total). Rejected if more than 5 minutes
+         * in the future or more than 7 days in the past.
+         */
+        occurredAt?: string;
+    }, options?: CallOptions): Promise<TrackResult>;
+    /** List a customer's live entitlements (one per feature). */
+    entitlements(customerId: string, options?: CallOptions): Promise<{
+        entitlements: EntitlementView[];
+    }>;
+    /** Start a subscription → returns a hosted checkout URL to redirect the customer to. */
+    attach(input: CreateSubscriptionInput, options?: RequestOptions): Promise<AttachResult>;
+}
+/**
+ * The browser-safe client: construct it with a **publishable** key (`bl_<env>_pk_…`)
+ * to read the public catalog from any origin (CORS-enabled). It exposes ONLY public,
+ * project-scoped reads — products and their prices — so it is safe to ship in a
+ * frontend bundle. Customer-scoped data (entitlements, checkout) is never reachable
+ * with a publishable key; use the server handler or a portal session for that.
+ */
+declare class BillowPublishable {
+    #private;
+    constructor(publishableKey: string, opts?: BillowOptions);
+    products: {
+        /** The active catalog — products and their prices, for a pricing table. */
+        list: (options?: CallOptions) => Promise<{
+            id: string;
+            slug: string;
+            name: string;
+            type: "recurring" | "one_time";
+            isAddOn: boolean;
+            metadata: Record<string, string>;
+            version: number;
+            archived: boolean;
+            prices: {
+                id: string;
+                kind: "one_time" | "fixed_recurring" | "licensed" | "usage";
+                interval: "day" | "week" | "month" | "year" | null;
+                intervalCount: number;
+                amount: number;
+                currency: string;
+                meterFeature: string | null;
+                usageModel: "graduated" | "volume" | "package" | "percentage" | "stairstep" | null;
+                usageTiers: {
+                    upTo: number | null;
+                    unitAmount: number;
+                    flatAmount?: number | undefined;
+                }[] | null;
+                packageSize: number | null;
+                rateBps: number | null;
+                taxRateBps: number | null;
+                taxBehavior: "inclusive" | "exclusive" | null;
+            }[];
+            entitlements: {
+                feature: string;
+                allowance: number | null;
+                resetInterval: "day" | "week" | "month" | "year" | null;
+                rollover: boolean;
+            }[];
+        }[]>;
+        /** Fetch one active product (with its prices) by slug. */
+        get: (slug: string, options?: CallOptions) => Promise<{
+            id: string;
+            slug: string;
+            name: string;
+            type: "recurring" | "one_time";
+            isAddOn: boolean;
+            metadata: Record<string, string>;
+            version: number;
+            archived: boolean;
+            prices: {
+                id: string;
+                kind: "one_time" | "fixed_recurring" | "licensed" | "usage";
+                interval: "day" | "week" | "month" | "year" | null;
+                intervalCount: number;
+                amount: number;
+                currency: string;
+                meterFeature: string | null;
+                usageModel: "graduated" | "volume" | "package" | "percentage" | "stairstep" | null;
+                usageTiers: {
+                    upTo: number | null;
+                    unitAmount: number;
+                    flatAmount?: number | undefined;
+                }[] | null;
+                packageSize: number | null;
+                rateBps: number | null;
+                taxRateBps: number | null;
+                taxBehavior: "inclusive" | "exclusive" | null;
+            }[];
+            entitlements: {
+                feature: string;
+                allowance: number | null;
+                resetInterval: "day" | "week" | "month" | "year" | null;
+                rollover: boolean;
+            }[];
+        }>;
+    };
+}
+/**
+ * The customer-surface client (Phase G, ADR-0014): construct it with a portal
+ * session token (minted by your backend via `billow.portalSessions.create`) to act
+ * as that one Customer. It exposes only their own data — no operator/secret-key
+ * surface — so the token can be held by a hosted portal app safely.
+ */
+declare class BillowPortal {
+    #private;
+    constructor(sessionToken: string, opts?: BillowOptions);
+    /** The portal shell: flow, return URL, merchant brand, and customer identity —
+     *  the lightweight payload the hosting app frames every page with, and the
+     *  validate-and-route check at login. */
+    session(options?: CallOptions): Promise<PortalSessionInfo>;
+    /** The self-serve home payload: identity + subscriptions + usage + saved cards. */
+    me(options?: CallOptions): Promise<PortalView>;
+    invoices: {
+        /** The Customer's invoices (newest first). Auto-paginating. */
+        list: (params?: ListParams & {
+            status?: InvoiceListItem["status"];
+        }, options?: CallOptions) => ListPromise<InvoiceListItem>;
+        /** Open or resume checkout for this customer's outstanding invoice. */
+        pay: (id: string, input?: PayInvoiceInput, options?: CallOptions) => Promise<{
+            invoiceId: string;
+            chargeId: string;
+            checkoutUrl: string;
+            status: "failed" | "processing";
+            expiresAt: string;
+        }>;
+        /** Download one of the Customer's invoices as a PDF (raw bytes). */
+        pdf: (id: string, options?: CallOptions) => Promise<ArrayBuffer>;
+        /** Download the payment receipt for one of the Customer's invoices (raw bytes). */
+        receiptPdf: (id: string, options?: CallOptions) => Promise<ArrayBuffer>;
+    };
+    subscriptions: {
+        /** Schedule one of the Customer's subscriptions to cancel at period end. */
+        cancel: (id: string) => Promise<PortalSubscriptionStatus>;
+        /** Reverse a scheduled period-end cancellation. */
+        resumeCancellation: (id: string) => Promise<PortalSubscriptionStatus>;
+        /** Move one of the Customer's subscriptions to another plan (upgrade now / downgrade scheduled). */
+        changePlan: (id: string, productId: string) => Promise<PortalPlanChange>;
+        /** Clear a pending downgrade. */
+        clearScheduledPlanChange: (id: string) => Promise<PortalSubscriptionStatus>;
+    };
+    paymentMethod: {
+        /** Open a checkout to save or replace the Customer's card (zero-amount tokenization). */
+        update: (returnUrl?: string) => Promise<PortalCardSetupResult>;
+    };
+    paymentMethods: {
+        list: (options?: CallOptions) => Promise<{
+            id: string;
+            brand: string | null;
+            last4: string | null;
+            expMonth: number | null;
+            expYear: number | null;
+            isDefault: boolean;
+            status: "active" | "expired" | "removed";
+            createdAt: string;
+            expiryStatus: "expired" | "unknown" | "valid" | "expiring";
+            canSetDefault: boolean;
+            canRemove: boolean;
+            removalBlockedReason: string | null;
+        }[]>;
+        setDefault: (id: string) => Promise<{
+            id: string;
+            brand: string | null;
+            last4: string | null;
+            expMonth: number | null;
+            expYear: number | null;
+            isDefault: boolean;
+            status: "active" | "expired" | "removed";
+            createdAt: string;
+            expiryStatus: "expired" | "unknown" | "valid" | "expiring";
+            canSetDefault: boolean;
+            canRemove: boolean;
+            removalBlockedReason: string | null;
+        }>;
+        remove: (id: string) => Promise<{
+            removed: boolean;
+        }>;
+    };
+    /** The checkout hand-off, for a session minted with `flow: "checkout"`. */
+    checkout: {
+        /** The plan being confirmed (product + base price). */
+        get: (options?: CallOptions) => Promise<PortalCheckout>;
+        /** Subscribe to the plan → returns the hosted Paymob checkout URL to redirect to. */
+        start: () => Promise<{
+            checkoutUrl: string | null;
+        }>;
+    };
+}
+
+export { AttachResult, BILLOW_ERROR_CODES, Billow, BillowApiError, type BillowErrorCode, BillowOptions, BillowPortal, BillowPublishable, type BusinessProfile, CallOptions, type CatalogItem, Charge, type ChargeListItem, type ChargeListParams, type ChargeSearchHit, ChargeStatus, CheckResult, type CheckoutMethodInfo, type ConfigField, type ConfigFieldOption, type ConfigFieldType, Coupon, CreateChargeInput, CreateCouponInput, CreateCreditGrantInput, CreateCreditPackInput, CreateCreditTopUpInput, CreateMerchantInitiatedChargeInput, type CreatePortalSessionInput, CreateProductInput, CreateSubscriptionInput, CreateUsageAlertInput, type CreateWebhookEndpointInput, type CredentialSet, CreditBalance, CreditGrant, CreditGrantRequestResult, CreditLedgerEntry, CreditPack, CreditPacks, CreditThresholdLevel, CreditTopUp, CreditTopUpListParams, CreditTopUpRequestResult, CreditUsage, CreditUsageParams, type CursorListParams, type CursorListPromise, type CursorPaginated, Customer, type CustomerAnonymizationResult, type CustomerCreditsExport, type CustomerDataExport, type CustomerListItem, type CustomerListParams, type CustomerOverview, type CustomerSearchHit, type CustomerUsage, type CustomerUsageDetail, type EmailDeliveryListItem, type EmailDeliveryListParams, type EmailDeliveryStatus, type EmailTemplateSetting, EntitlementView, type ExchangeRate, type ExportJsonValue, type ExternalPaymentMethod, type ExternalPaymentResult, Feature, FeatureKind, IdempotentRequestOptions, type InboundWebhookListItem, type InboundWebhookListParams, type InboundWebhookOutcome, type IntegrationDefinition, type IntegrationKind, type IntegrationTier, type Invoice, type InvoiceDetail, type InvoiceLineItem, type InvoiceListItem, type InvoiceListParams, type InvoiceSearchHit, InvoiceStatus, type ListParams, type ListPromise, MeterConfig, type MetricsOverview, type MetricsParams, type MetricsRollup, MigrationResult, type OutboxEventListItem, type OutboxEventListParams, type OutboxEventStatus, type Paginated, PayInvoiceInput, type PaymentMethod, PaymentMethodStatus, type PaymentProviderDefinition, type PortalCardSetupResult, type PortalCheckout, type PortalPlanChange, type PortalSession, type PortalSessionFlow, type PortalSessionInfo, type PortalSubscriptionStatus, type PortalView, type ProviderCredentialSummary, type ProviderVerifyResult, type ProviderVerifyTarget, type ProviderVerifyTargetResult, type RecordExternalPaymentInput, type Refund, type RefundChargeInput, type RefundRequestResult, type RefundReviewReason, RefundStatus, RequestOptions, type ResolveRefundInput, SavedPaymentMethod, type ScheduledSubscriptionChange, type SearchResults, type SubscriptionListItem, type SubscriptionListParams, type SubscriptionSearchHit, SubscriptionStatus, TaxBehavior, type TimeseriesInterval, type TimeseriesMetric, type TimeseriesParams, type TimeseriesPoint, type TimeseriesResult, TrackResult, UnappliedPaymentReason, type UpdateBusinessProfileInput, UpdateCreditPackInput, type UpdateEmailTemplateInput, UpdateFeatureInput, UpdateProductInput, type UpdateWebhookEndpointInput, type UpsertCredentialsInput, UsageAlert, type WebhookDelivery, WebhookDeliveryStatus, type WebhookEndpoint, type WebhookEndpointWithSecret, type Whoami, currencyExponent, formatMoney, isSecretField, toMajorUnits, toMinorUnits };