@secureprocessing/node 0.0.0-stage → 0.2.1

package/dist/types.d.ts

@@ -0,0 +1,892 @@
+/** The objects the API returns. Amounts are integers in the currency's minor unit. */
+export type Currency = "bzd" | "usd";
+/**
+ * Key-value pairs of your own, stored on the object and returned exactly as you sent them. Never
+ * shown to the customer. An update REPLACES the whole object; it does not merge into it.
+ *
+ * Limits, enforced by the API with a `400` (Stripe's, so a payload moves between the two unchanged):
+ * at most 50 keys; keys 1–40 characters with no `[` or `]` (the payments list filters on
+ * `metadata[key]=value`, and a bracketed key could be stored but never searched for); values are
+ * strings of up to 500 characters.
+ */
+export type MetadataParam = Record<string, string>;
+export interface ListResponse<T> {
+    object: "list";
+    url: string;
+    has_more: boolean;
+    data: T[];
+}
+export interface GatewayEvidence {
+    order_id: string | null;
+    order_status: number | null;
+    action_code: string | null;
+    approval_code: string | null;
+    masked_pan: string | null;
+    card_brand: string | null;
+}
+export type PaymentIntentStatus = "requires_payment_method" | "processing" | "requires_action" | "requires_capture" | "succeeded" | "canceled";
+export interface PaymentIntent {
+    id: string;
+    object: "payment_intent";
+    amount: number;
+    amount_received: number;
+    amount_capturable: number;
+    amount_refunded: number;
+    currency: Currency;
+    status: PaymentIntentStatus;
+    capture_method: "automatic" | "manual";
+    customer: string | null;
+    payment_method: string | null;
+    description: string | null;
+    receipt_email: string | null;
+    client_secret: string;
+    /** What the card was actually charged, and at what rate. A USD payment settles in BZD. */
+    settlement_amount: number | null;
+    settlement_currency: string | null;
+    fx_rate: number | null;
+    last_payment_error: {
+        type: string;
+        code: string;
+        decline_code?: string;
+        message: string;
+    } | null;
+    next_action: Record<string, unknown> | null;
+    /** What the bank reported. Useful when reconciling against the bank's own portal. */
+    gateway: GatewayEvidence | null;
+    /**
+     * What our risk rules decided before the bank was called.
+     *
+     * 🔴 `null` means NOT ASSESSED — the payment predates the check, or it was created by a path
+     * that never reaches a checkout page. It does not mean allowed.
+     */
+    risk_outcome: RiskOutcome | null;
+    /** The review a `review` outcome opened once the payment succeeded, if any. */
+    review: string | null;
+    /**
+     * Whether a chargeback or an inquiry has ever been raised against this payment.
+     *
+     * A boolean rather than an id: a payment can be disputed more than once (a second presentment is
+     * a real thing), so no single id would be right. List `disputes` filtered by `payment_intent`.
+     */
+    disputed: boolean;
+    cancellation_reason: string | null;
+    livemode: boolean;
+    metadata: Record<string, string>;
+    created: number;
+}
+export interface CheckoutSession {
+    id: string;
+    object: "checkout_session";
+    payment_intent: string;
+    status: "open" | "complete" | "expired";
+    /** Send the customer here. Null once the session is no longer open. */
+    url: string | null;
+    success_url: string;
+    cancel_url: string | null;
+    customer_email: string | null;
+    amount_total: number;
+    currency: Currency;
+    expires_at: number;
+    livemode: boolean;
+    metadata: Record<string, string>;
+    created: number;
+}
+export interface Refund {
+    id: string;
+    object: "refund";
+    payment_intent: string;
+    amount: number;
+    currency: Currency;
+    status: "pending" | "succeeded" | "failed" | "canceled";
+    reason: string | null;
+    /**
+     * `bank_portal` means somebody refunded it in the bank's own interface and we found it.
+     * `review` means it was given back from the risk queue rather than decided as an ordinary refund.
+     */
+    origin: "api" | "dashboard" | "bank_portal" | "reconcile" | "review";
+    failure_reason: string | null;
+    livemode: boolean;
+    metadata: Record<string, string>;
+    created: number;
+}
+export interface Customer {
+    id: string;
+    object: "customer";
+    email: string | null;
+    name: string | null;
+    phone: string | null;
+    description: string | null;
+    livemode: boolean;
+    metadata: Record<string, string>;
+    created: number;
+}
+export interface PaymentMethod {
+    id: string;
+    object: "payment_method";
+    type: "card";
+    customer: string;
+    card: {
+        brand: string | null;
+        last4: string | null;
+        exp_month: number | null;
+        exp_year: number | null;
+    };
+    status: "active" | "detached" | "expired";
+    livemode: boolean;
+    created: number;
+}
+export interface Product {
+    id: string;
+    object: "product";
+    /** False means archived. Its prices are left alone. */
+    active: boolean;
+    name: string;
+    description: string | null;
+    images: string[];
+    statement_descriptor: string | null;
+    livemode: boolean;
+    metadata: Record<string, string>;
+    created: number;
+    updated: number;
+}
+/** A range the payer chooses an amount within. Minor units, like everything else. */
+export interface CustomUnitAmount {
+    minimum: number;
+    maximum: number;
+    preset?: number;
+}
+/**
+ * What a product costs.
+ *
+ * 🔴 Immutable apart from `active`, `nickname` and `metadata`. A price id is what a payment link
+ * stores, so changing the amount would silently reprice every link already in circulation. To
+ * change what something costs, create a new price and archive the old one.
+ */
+export interface Price {
+    id: string;
+    object: "price";
+    active: boolean;
+    product: string;
+    currency: Currency;
+    type: "one_time";
+    billing_scheme: "per_unit";
+    /** Minor units — 6000 is $60.00. Null when the price takes a custom amount. */
+    unit_amount: number | null;
+    custom_unit_amount: CustomUnitAmount | null;
+    nickname: string | null;
+    livemode: boolean;
+    metadata: Record<string, string>;
+    created: number;
+}
+export interface CreateProductParams {
+    name: string;
+    description?: string;
+    active?: boolean;
+    /** Up to 8 https URLs. */
+    images?: string[];
+    statement_descriptor?: string;
+    metadata?: MetadataParam;
+}
+export interface UpdateProductParams {
+    name?: string;
+    description?: string | null;
+    active?: boolean;
+    images?: string[];
+    statement_descriptor?: string;
+    metadata?: MetadataParam;
+}
+export interface CreatePriceParams {
+    product: string;
+    currency: Currency;
+    /** Minor units. Give this or `custom_unit_amount`, never both and never neither. */
+    unit_amount?: number;
+    custom_unit_amount?: CustomUnitAmount;
+    nickname?: string;
+    active?: boolean;
+    metadata?: MetadataParam;
+}
+/** Only these three. The amount, the currency and the product are fixed for the price's life. */
+export interface UpdatePriceParams {
+    active?: boolean;
+    nickname?: string | null;
+    metadata?: MetadataParam;
+}
+/** How many of the thing a payer may buy. Both bounds are required when `enabled` is true. */
+export interface AdjustableQuantity {
+    enabled: boolean;
+    minimum?: number;
+    maximum?: number;
+}
+/** A question asked on the hosted page. The answer arrives in the payment's metadata. */
+export interface PaymentLinkCustomField {
+    key: string;
+    label: string;
+    type: "text" | "numeric" | "dropdown";
+    optional?: boolean;
+    /** Required for `dropdown`, refused for anything else. */
+    options?: string[];
+}
+/** What the payer sees once they have paid. A redirect url must be https. */
+export type AfterCompletion = {
+    type: "hosted_confirmation";
+    message?: string;
+} | {
+    type: "redirect";
+    url: string;
+};
+export interface PaymentLink {
+    id: string;
+    object: "payment_link";
+    active: boolean;
+    /** The page to share. The id in it is the token — it is public by design. */
+    url: string;
+    price: string;
+    quantity: number;
+    adjustable_quantity: AdjustableQuantity | null;
+    custom_fields: PaymentLinkCustomField[];
+    after_completion: AfterCompletion;
+    collect_customer_name: boolean;
+    collect_phone: boolean;
+    livemode: boolean;
+    metadata: Record<string, string>;
+    created: number;
+}
+export interface CreatePaymentLinkParams {
+    /** An ACTIVE price of yours. Its amount is what the link charges, for ever. */
+    price: string;
+    quantity?: number;
+    adjustable_quantity?: AdjustableQuantity;
+    /** Up to three. The answers arrive in each payment's metadata under `payment_link_fields`. */
+    custom_fields?: PaymentLinkCustomField[];
+    after_completion?: AfterCompletion;
+    collect_customer_name?: boolean;
+    collect_phone?: boolean;
+    metadata?: MetadataParam;
+}
+/** 🔴 No `price` and no `quantity`: see the note on `paymentLinks.update`. */
+export interface UpdatePaymentLinkParams {
+    active?: boolean;
+    after_completion?: AfterCompletion;
+    custom_fields?: PaymentLinkCustomField[];
+    adjustable_quantity?: AdjustableQuantity | null;
+    collect_customer_name?: boolean;
+    collect_phone?: boolean;
+    metadata?: MetadataParam;
+}
+export interface TaxRate {
+    id: string;
+    object: "tax_rate";
+    display_name: string;
+    /** The rate as a percentage, to three decimal places. 12.5 means 12.5%. */
+    percentage: number;
+    /**
+     * True when a line's amount ALREADY contains the tax and it is backed out of it; false when the
+     * tax is added on top. 1000 at an inclusive 12.5% is 111 of tax on 889 net; the same rate
+     * exclusive is 125 of tax on 1000 net.
+     */
+    inclusive: boolean;
+    jurisdiction: string | null;
+    active: boolean;
+    livemode: boolean;
+    metadata: Record<string, string>;
+    created: number;
+}
+export interface CreateTaxRateParams {
+    display_name: string;
+    percentage: number;
+    inclusive: boolean;
+    jurisdiction?: string;
+    metadata?: MetadataParam;
+}
+/**
+ * 🔴 No `percentage` and no `inclusive`. A finalized invoice names the rate that produced the tax
+ * printed on it, so a rate that moved would make the two disagree on a document your customer is
+ * already holding. Create a new rate and archive this one.
+ */
+export interface UpdateTaxRateParams {
+    display_name?: string;
+    active?: boolean;
+    metadata?: MetadataParam;
+}
+export type InvoiceStatus = "draft" | "open" | "paid" | "void" | "uncollectible";
+export interface InvoiceLineItem {
+    id: string;
+    object: "line_item";
+    description: string;
+    quantity: number;
+    /** Minor units. */
+    unit_amount: number;
+    /** Minor units. `quantity × unit_amount`; for an inclusive rate it INCLUDES the tax. */
+    amount: number;
+    /** Minor units. The tax attributable to this line alone. */
+    tax_amount: number;
+    price: string | null;
+    tax_rate: string | null;
+    metadata: Record<string, string>;
+}
+export interface Invoice {
+    id: string;
+    object: "invoice";
+    status: InvoiceStatus;
+    /** Assigned at finalize from your own consecutive sequence. Null while a draft. */
+    number: string | null;
+    customer: string;
+    currency: Currency;
+    collection_method: "send_invoice";
+    /** Minor units, net of tax. */
+    subtotal: number;
+    /** Minor units. */
+    tax: number;
+    /** Minor units. `subtotal + tax`. */
+    total: number;
+    /** Minor units. Can exceed `total` — see `amount_due`. */
+    amount_paid: number;
+    /**
+     * `total − amount_paid`, in minor units. NEGATIVE on an overpayment, which happens when two
+     * browser tabs on the hosted page are both paid. Reported rather than clamped: money that moved
+     * is money you owe back.
+     */
+    amount_due: number;
+    allow_partial: boolean;
+    /**
+     * 🔴 The page to send the customer. Its token is NOT this object's id — the id is safe in a log
+     * and this URL is not, because the page names the customer and what they owe.
+     */
+    hosted_invoice_url: string;
+    /** The same document as a PDF. Requires your API key, so it is for your records. */
+    invoice_pdf: string;
+    /** Unix timestamp, seconds. */
+    due_date: number | null;
+    description: string | null;
+    memo: string | null;
+    footer: string | null;
+    custom_fields: {
+        name: string;
+        value: string;
+    }[];
+    lines: {
+        object: "list";
+        data: InvoiceLineItem[];
+    };
+    finalized_at: number | null;
+    paid_at: number | null;
+    voided_at: number | null;
+    sent_at: number | null;
+    reminder_count: number;
+    latest_payment_intent: string | null;
+    livemode: boolean;
+    metadata: Record<string, string>;
+    created: number;
+}
+export interface CreateInvoiceParams {
+    customer: string;
+    currency?: Currency;
+    /** Unix seconds. Give this OR `days_until_due`, not both. */
+    due_date?: number;
+    /** Counted from the moment you FINALIZE, not from now. Give this OR `due_date`. */
+    days_until_due?: number;
+    description?: string;
+    memo?: string;
+    footer?: string;
+    custom_fields?: {
+        name: string;
+        value: string;
+    }[];
+    allow_partial?: boolean;
+    metadata?: MetadataParam;
+}
+/**
+ * 🔴 Nothing here changes money. A draft's amounts come from its lines; a finalized invoice's are
+ * frozen. Once the invoice is open, only `memo`, `footer` and `metadata` are accepted — everything
+ * else is a term of a bill the customer already has.
+ */
+export interface UpdateInvoiceParams {
+    due_date?: number;
+    days_until_due?: number;
+    description?: string;
+    memo?: string;
+    footer?: string;
+    custom_fields?: {
+        name: string;
+        value: string;
+    }[];
+    allow_partial?: boolean;
+    metadata?: MetadataParam;
+}
+export interface CreateInvoiceItemParams {
+    /** The DRAFT invoice to add the line to. */
+    invoice: string;
+    /** A price of yours. Its amount and currency are copied onto the line. */
+    price?: string;
+    /** Minor units. Give this and `description`, or give `price`. */
+    unit_amount?: number;
+    description?: string;
+    quantity?: number;
+    tax_rate?: string;
+    metadata?: MetadataParam;
+}
+export interface UpdateInvoiceItemParams {
+    description?: string;
+    quantity?: number;
+    /** Minor units. Setting it drops the line's link to a price. */
+    unit_amount?: number;
+    tax_rate?: string | null;
+    metadata?: MetadataParam;
+}
+export interface DeletedInvoiceItem {
+    id: string;
+    object: "invoice_item";
+    deleted: true;
+}
+/**
+ * What you are owed, and what is not yours to spend yet.
+ *
+ * 🔴 In the SETTLEMENT currency (BZD), not the currency a payment was priced in. A payment taken in
+ * USD is settled in Belize dollars at the rate recorded on that payment, and the balance is the sum
+ * of what actually moved, not of what was quoted.
+ */
+/** What an account may do, per capability. */
+export type CapabilityStatus = "inactive" | "pending" | "active";
+export type ApplicationStatus = "draft" | "submitted" | "in_review" | "approved" | "rejected" | "more_info";
+/**
+ * Your own account: what it is, and what it is allowed to do.
+ *
+ * 🔴 `live_enabled` is the one to branch on before attempting anything with a live key. It is false
+ * until we have approved the business, and a live request from an account that is not enabled is
+ * refused rather than quietly downgraded to test data.
+ */
+export interface Account {
+    id: string;
+    object: "account";
+    name: string;
+    live_enabled: boolean;
+    capabilities: {
+        card_payments: CapabilityStatus;
+        payouts: CapabilityStatus;
+    };
+    /** Null until the activation application has been started from the dashboard. */
+    application_status: ApplicationStatus | null;
+    requirements: {
+        /**
+         * What the application still needs, as keys such as `business.address` or
+         * `persons.owner_or_director`. Empty means it can be submitted. Filling it in is done from the
+         * dashboard — see https://docs.secureprocessing.app/activation.
+         */
+        currently_due: string[];
+    };
+}
+export interface BalanceAmount {
+    amount: number;
+    currency: string;
+}
+export interface Balance {
+    object: "balance";
+    /** Taken, but not yet released to you. */
+    pending: BalanceAmount[];
+    /** Yours, and payable. */
+    available: BalanceAmount[];
+    /** Already drawn for a payout the bank has not yet confirmed. Neither pending nor available. */
+    payouts_in_transit: BalanceAmount[];
+    livemode: boolean;
+}
+export type PayoutStatus = "pending" | "in_transit" | "paid" | "canceled" | "failed";
+export interface Payout {
+    id: string;
+    object: "payout";
+    /** Minor units. Payouts are always BZD: it is what leaves the pooled merchant account. */
+    amount: number;
+    currency: "bzd";
+    status: PayoutStatus;
+    method: "bank_transfer";
+    /** Never the full account number — only the last four, as they were at the moment of the cut. */
+    destination: {
+        bank_name: string | null;
+        account_name: string | null;
+        account_last4: string | null;
+    };
+    arrival_date: string | null;
+    /** The bank's own transfer reference. Present once the payout is `paid`. */
+    bank_reference: string | null;
+    failure_reason: string | null;
+    livemode: boolean;
+    created: number;
+    paid_at: number | null;
+}
+export type BalanceTransactionType = "charge" | "refund" | "payout" | "payout_reversal" | "adjustment" | "dispute" | "dispute_reversal";
+/**
+ * One movement of your balance.
+ *
+ * `net` is the column that sums to your balance — over the whole list it equals
+ * `pending + available`. A charge appears ONCE and its `status` changes from `pending` to
+ * `available` when the settlement delay passes; the release is not a second transaction.
+ */
+export interface BalanceTransaction {
+    id: string;
+    object: "balance_transaction";
+    type: BalanceTransactionType;
+    /** Signed, in your favour positive. A refund and a payout are negative. */
+    amount: number;
+    /** Signed. Positive when we earned it here, negative when a refund gave it back. */
+    fee: number;
+    /** `amount - fee`. */
+    net: number;
+    currency: string;
+    /** The payment intent, refund or payout this belongs to. */
+    source: string;
+    status: "pending" | "available";
+    available_on: number;
+    created: number;
+}
+/** Both sides of a balance at one instant, in minor units of your settlement currency. */
+export interface BalanceSide {
+    available: number;
+    pending: number;
+}
+/**
+ * A period, summarised — and checked.
+ *
+ * 🔴 `reconciled` is the field to look at. `ending_balance` is derived from the period's movements
+ * on top of `starting_balance`; `ledger` is the same two figures recomputed from the ledger's own
+ * entries at the moment of the request. If they disagree, `reconciled` is false and your statement
+ * and your balance are telling you different things — that is a support call, not a number to
+ * reconcile around.
+ *
+ * Every figure is SIGNED the way the ledger signs it: a charge positive, a refund and a payout
+ * negative, `fees_returned` negative because it is a fee coming back. They add up to
+ * `ending_balance − starting_balance`, which is what makes this a statement rather than a set of
+ * numbers.
+ */
+export interface BalanceSummary {
+    object: "balance_summary";
+    currency: string;
+    /** `start` is inclusive; `end` is EXCLUSIVE, so twelve monthly summaries tile a year exactly. */
+    period: {
+        start: number;
+        end: number;
+    };
+    starting_balance: BalanceSide;
+    activity: {
+        charges: {
+            count: number;
+            gross: number;
+            fees: number;
+            net: number;
+        };
+        refunds: {
+            count: number;
+            amount: number;
+            fees_returned: number;
+        };
+        payouts: {
+            count: number;
+            amount: number;
+        };
+        payout_reversals: {
+            count: number;
+            amount: number;
+        };
+        adjustments: {
+            count: number;
+            amount: number;
+        };
+        /** Zero today. The field is here so you read a number rather than branch on an absence. */
+        disputes: {
+            count: number;
+            amount: number;
+        };
+    };
+    ending_balance: BalanceSide;
+    ledger: BalanceSide;
+    reconciled: boolean;
+    livemode: boolean;
+}
+/**
+ * A reporting window. A unix timestamp in seconds, or an ISO date like `2026-09-01` (UTC midnight).
+ *
+ * Defaults to the current calendar month up to now. At most 366 days; for a longer span, ask one
+ * window at a time.
+ */
+export interface ReportWindowParams {
+    start?: string | number;
+    end?: string | number;
+}
+export type ExportKind = "payments" | "refunds" | "payouts" | "balance_transactions";
+export interface ExportParams extends ReportWindowParams {
+    /** `payments`, `refunds` and `payouts` each take their own resource's status values. */
+    status?: string;
+    /** `payments` only. */
+    customer?: string;
+    /** `payments` only. */
+    payment_link?: string;
+    /** `balance_transactions` only. */
+    type?: BalanceTransactionType;
+    /** `balance_transactions` only: what one payout covers. */
+    payout?: string;
+}
+export interface SecureProcessingEvent<T = Record<string, unknown>> {
+    id: string;
+    object: "event";
+    type: string;
+    api_version: string;
+    data: {
+        object: T;
+    };
+    livemode: boolean;
+    created: number;
+}
+export interface WebhookEndpoint {
+    id: string;
+    object: "webhook_endpoint";
+    url: string;
+    description: string | null;
+    enabled_events: string[];
+    status: "enabled" | "disabled";
+    /** Present only in the response that created or rotated it. */
+    secret?: string;
+    livemode: boolean;
+    created: number;
+}
+/**
+ * One attempt-tracked delivery of one event to one endpoint.
+ *
+ * ⚠️ `next_attempt_at` is null once a delivery is `succeeded` or `dead` — there is no next attempt.
+ * A `dead` delivery exhausted the retry schedule (about 35 hours); the event is still readable
+ * through `events.list`, so a missed webhook is recoverable without our help.
+ */
+export interface WebhookDelivery {
+    id: string;
+    object: "webhook_delivery";
+    endpoint: string;
+    event: string;
+    event_type: string;
+    status: "pending" | "succeeded" | "failed" | "dead";
+    attempt_count: number;
+    last_response_status: number | null;
+    last_error: string | null;
+    next_attempt_at: number | null;
+    created: number;
+}
+export interface CreatePaymentIntentParams {
+    amount: number;
+    currency: Currency;
+    capture_method?: "automatic" | "manual";
+    customer?: string;
+    payment_method?: string;
+    off_session?: boolean;
+    confirm?: boolean;
+    setup_future_usage?: "off_session";
+    /** Reaches the bank's own record. Lead with your own reference so you can find it later. */
+    description?: string;
+    receipt_email?: string;
+    statement_descriptor_suffix?: string;
+    return_url?: string;
+    metadata?: MetadataParam;
+}
+export interface CreateCheckoutSessionParams {
+    payment_intent?: string;
+    amount?: number;
+    currency?: Currency;
+    success_url: string;
+    cancel_url?: string;
+    customer?: string;
+    customer_email?: string;
+    line_items?: {
+        name: string;
+        amount?: number;
+        quantity?: number;
+    }[];
+    description?: string;
+    setup_future_usage?: "off_session";
+    metadata?: MetadataParam;
+}
+export interface CreateRefundParams {
+    payment_intent: string;
+    /** Omit to refund everything that is left. */
+    amount?: number;
+    reason?: "duplicate" | "fraudulent" | "requested_by_customer" | "other";
+    metadata?: MetadataParam;
+}
+export interface ListParams {
+    limit?: number;
+    starting_after?: string;
+    ending_before?: string;
+}
+export interface ListPaymentIntentsParams extends ListParams {
+    status?: PaymentIntentStatus;
+    customer?: string;
+    created_gte?: number;
+    created_lte?: number;
+    /** Filter by your own identifiers: `{ shop_id: "scuba-sensation" }`. */
+    metadata?: Record<string, string>;
+    risk_outcome?: RiskOutcome;
+    /** Every payment taken through one payment link. The payment-links page filters on it. */
+    payment_link?: string;
+    /** Every payment taken against one invoice; a partially paid invoice has more than one. */
+    invoice?: string;
+    created_via?: "api" | "checkout" | "dashboard" | "payment_link" | "invoice";
+}
+export type RiskOutcome = "allow" | "block" | "review";
+/**
+ * What a rule can test.
+ *
+ * `amount_minor` and the five counts are numbers; `currency`, `email`, `email_domain` and
+ * `ip_country` are strings. There is deliberately no card country: the gateway does not tell us
+ * the issuing country, and an attribute that can never be populated is a rule that silently never
+ * fires.
+ */
+export type RiskAttribute = "amount_minor" | "currency" | "email" | "email_domain" | "ip_country" | "velocity_email_1h" | "velocity_email_24h" | "velocity_ip_1h" | "velocity_ip_24h" | "attempts_email_24h";
+export type RiskOperator = "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "in" | "not_in" | "contains" | "ends_with";
+export interface RiskCondition {
+    attr: RiskAttribute;
+    op: RiskOperator;
+    value: number | string | number[] | string[];
+}
+/** An AND of one to eight conditions. There is no `any` and no nesting: an OR is two rules. */
+export interface RiskPredicate {
+    all: RiskCondition[];
+}
+export interface RiskRule {
+    id: string;
+    object: "risk_rule";
+    name: string;
+    action: "block" | "review";
+    predicate: RiskPredicate;
+    enabled: boolean;
+    priority: number;
+    /** True for a rule Secure Processing applies to every business. You cannot edit those. */
+    platform_default: boolean;
+    /** Null on a platform default, which applies in test and live alike. */
+    livemode: boolean | null;
+    metadata: Record<string, string>;
+    created: number;
+    updated: number;
+}
+export interface CreateRiskRuleParams {
+    name: string;
+    action: "block" | "review";
+    predicate: RiskPredicate;
+    enabled?: boolean;
+    priority?: number;
+    metadata?: MetadataParam;
+}
+/** 🔴 No predicate and no action: a changed test is a new rule. See `riskRules.update`. */
+export interface UpdateRiskRuleParams {
+    name?: string;
+    enabled?: boolean;
+    priority?: number;
+    metadata?: MetadataParam;
+}
+export type RiskListKind = "email" | "email_domain" | "ip" | "card_fingerprint";
+export interface RiskListItem {
+    id: string;
+    object: "risk_list_item";
+    list: "allow" | "block";
+    kind: RiskListKind;
+    value: string;
+    note: string | null;
+    livemode: boolean;
+    created: number;
+}
+export interface CreateRiskListItemParams {
+    list: "allow" | "block";
+    kind: RiskListKind;
+    value: string;
+    note?: string;
+}
+export interface Review {
+    id: string;
+    object: "review";
+    payment_intent: string;
+    risk_evaluation: string | null;
+    /** Which rules asked for a look, in words. */
+    reason: string | null;
+    status: "open" | "approved" | "refunded";
+    opened: number;
+    closed: number | null;
+    closed_reason: string | null;
+    livemode: boolean;
+}
+export type DisputeReason = "bank_cannot_process" | "check_returned" | "credit_not_processed" | "customer_initiated" | "debit_not_authorized" | "duplicate" | "fraudulent" | "general" | "incorrect_account_details" | "insufficient_funds" | "product_not_received" | "product_unacceptable" | "subscription_canceled" | "unrecognized";
+/**
+ * A `warning_` status is an INQUIRY — a retrieval request. No money has been taken and none is
+ * held. Everything else is a chargeback, and the disputed amount is out of your available balance
+ * until the case closes.
+ */
+export type DisputeStatus = "warning_needs_response" | "warning_under_review" | "warning_closed" | "needs_response" | "under_review" | "won" | "lost";
+/**
+ * Evidence, with Stripe's field names.
+ *
+ * The nine fields whose names end in a document — `receipt`, `shipping_documentation`,
+ * `customer_signature` and so on — take a `file_` id from `files.create` with
+ * `purpose: "dispute_evidence"`. The rest are text, up to 20000 characters. `null` clears a field.
+ */
+export interface DisputeEvidence {
+    access_activity_log?: string | null;
+    billing_address?: string | null;
+    cancellation_policy?: string | null;
+    cancellation_policy_disclosure?: string | null;
+    cancellation_rebuttal?: string | null;
+    customer_communication?: string | null;
+    customer_email_address?: string | null;
+    customer_name?: string | null;
+    customer_purchase_ip?: string | null;
+    customer_signature?: string | null;
+    duplicate_charge_documentation?: string | null;
+    duplicate_charge_explanation?: string | null;
+    duplicate_charge_id?: string | null;
+    product_description?: string | null;
+    receipt?: string | null;
+    refund_policy?: string | null;
+    refund_policy_disclosure?: string | null;
+    refund_refusal_explanation?: string | null;
+    service_date?: string | null;
+    service_documentation?: string | null;
+    shipping_address?: string | null;
+    shipping_carrier?: string | null;
+    shipping_date?: string | null;
+    shipping_documentation?: string | null;
+    shipping_tracking_number?: string | null;
+    uncategorized_file?: string | null;
+    uncategorized_text?: string | null;
+}
+export interface Dispute {
+    id: string;
+    object: "dispute";
+    /** Minor units, in the payment's own currency. */
+    amount: number;
+    currency: string;
+    /** Minor units of BZD: what actually moved in the ledger, at the rate the payment was taken at. */
+    settlement_amount: number;
+    settlement_currency: string;
+    payment_intent: string;
+    reason: DisputeReason;
+    status: DisputeStatus;
+    evidence: DisputeEvidence;
+    evidence_details: {
+        /** Unix seconds. Belize Bank gives no second chance. */
+        due_by: number;
+        has_evidence: boolean;
+        submission_count: number;
+        past_due: boolean;
+        submission_open: boolean;
+    };
+    balance_transactions: string[];
+    is_charge_refundable: boolean;
+    network_reason_code: string | null;
+    /** Belize Bank's own reference for the case. Quote it if you speak to them directly. */
+    bank_case_reference: string;
+    bank_opened_at: string | null;
+    /** What we charged for handling a loss, in BZD minor units. */
+    dispute_fee: number;
+    outcome_note: string | null;
+    merchant_accepted: boolean;
+    closed_at: number | null;
+    livemode: boolean;
+    created: number;
+}
+export interface UpdateDisputeParams {
+    /** MERGES with what is already on file. Pass `null` to clear a field. */
+    evidence?: DisputeEvidence;
+    /** Send it. After this the evidence is frozen. */
+    submit?: boolean;
+}