@leaflow/sdk 0.108.0 → 0.109.0

package/dist/billing/v1/generated/models.d.ts

@@ -0,0 +1,3337 @@
+/**
+ * Generated by orval 🍺
+ * Do not edit manually.
+ * Leaflow Billing API
+ * Products, prices, orders, subscriptions and account billing. Financial operations require an account access token and billing-account authorization. Public catalogue operations declare no security requirement.
+ * OpenAPI spec version: v1
+ */
+/**
+ * Whether a fulfilled purchase may end immediately or only after its paid term. Does not grant a refund. When absent, the terms are not configured and termination requires review.
+ */
+export type TerminationPolicy = (typeof TerminationPolicy)[keyof typeof TerminationPolicy];
+export declare const TerminationPolicy: {
+    readonly immediate: "immediate";
+    readonly period_end: "period_end";
+};
+/**
+ * none refunds nothing. prorated refunds the amount paid for the current period minus the value of
+ * the time used, never below zero and never more than what remains unrefunded. The time used runs
+ * from the period start to the effective cancellation time and is valued at the plan's
+ * shorter-period prices in the same currency, frozen at purchase as the order item's
+ * refund_monthly_amount and refund_hourly_amount: each full calendar month at the one-month prepaid
+ * price, the remainder at the postpaid hourly price or, without one, at the one-month price by the
+ * second. When the plan has no prepaid period shorter than the one bought, the time used is valued
+ * at the price paid, pro rata by the second. Discounts are not refunded, as they were never paid,
+ * and setup fees are excluded. The refunded part returns to the payment sources it came from. Tax
+ * paid is refunded in the same proportion as the amount it was paid on.
+ */
+export type RefundPolicy = (typeof RefundPolicy)[keyof typeof RefundPolicy];
+export declare const RefundPolicy: {
+    readonly none: "none";
+    readonly prorated: "prorated";
+};
+/**
+ * A decimal string, in the currency stated alongside it.
+ *
+ * **The currency is not part of this type.** It is carried by a `currency` field next to the
+ * amount, or by the account the amount belongs to. Reading an amount without that field is
+ * reading a number with no unit.
+ *
+ * It is a string rather than a JSON number because a JSON number is a float in most parsers,
+ * and a float loses precision on the first arithmetic. Nothing on this platform puts an amount
+ * through a float.
+ */
+export type Money = string;
+export interface CheckoutOrderRequest {
+    /**
+     * The code to apply, evaluated again at confirmation. Omit to select an applicable account
+     * discount. On an already confirmed checkout, omission retains the recorded discount.
+     * @minLength 1
+     * @maxLength 64
+     */
+    promotion_code?: string;
+    /**
+     * Quote.total in the order's currency, after discounts and tax but before applying credit
+     * grants or balance. Omit to skip the amount comparison; an explicit zero is compared.
+     * A different total fails with BILLING_AMOUNT_CHANGED. Must be a non-negative decimal
+     * string; empty strings, null, JSON numbers, signs and exponent notation are rejected.
+     */
+    expected_amount?: Money & string;
+}
+export type QuoteRenewalInterval = (typeof QuoteRenewalInterval)[keyof typeof QuoteRenewalInterval];
+export declare const QuoteRenewalInterval: {
+    readonly day: "day";
+    readonly month: "month";
+    readonly year: "year";
+};
+/**
+ * Price renewing a prepaid subscription. Give `price_id`, or `interval` with
+ * `interval_count`, to renew for another term at the price currently sold for it. Naming
+ * the current term, or giving neither, renews at the agreed amount. A term sold at several
+ * prices that differ in termination policy is refused with 409
+ * `BILLING_RENEWAL_OPTION_AMBIGUOUS` unless `termination_policy` or `price_id` is given.
+ */
+export interface QuoteRenewal {
+    subscription_id: string;
+    price_id?: string;
+    interval?: QuoteRenewalInterval;
+    /** @minimum 1 */
+    interval_count?: number;
+    /** With `interval` and `interval_count`, chooses among prices of that term that differ in termination policy. */
+    termination_policy?: TerminationPolicy;
+    /**
+     * How many consecutive periods to renew for.
+     * @minimum 1
+     * @maximum 100
+     */
+    periods?: number;
+}
+export type QuoteRenewalResultInterval = (typeof QuoteRenewalResultInterval)[keyof typeof QuoteRenewalResultInterval];
+export declare const QuoteRenewalResultInterval: {
+    readonly day: "day";
+    readonly month: "month";
+    readonly year: "year";
+};
+/**
+ * What renewing would charge. Renewing the same subscription for the same term and number
+ * of periods charges exactly `total`, unless prices or the discounts the account holds
+ * change in between.
+ */
+export interface QuoteRenewalResult {
+    /** Which renewal of the request this answers. */
+    index: number;
+    subscription_id: string;
+    /** The price the renewal is charged under. */
+    price_id: string;
+    interval: QuoteRenewalResultInterval;
+    interval_count: number;
+    periods: number;
+    /**
+     * The price of the periods before the discounts the account holds. A discount the
+     * subscription already carries is reflected here. Contains tax only where the price
+     * itself includes it.
+     */
+    amount: Money;
+    /** The reduction from a discount the account holds. */
+    discount_amount: Money;
+    /** Tax on the discounted amount. */
+    tax_amount: Money;
+    /** The part of `tax_amount` already contained in `amount`. */
+    tax_included_amount: Money;
+    /**
+     * What renewing would charge: `amount` less `discount_amount`, plus `tax_amount`, less
+     * `tax_included_amount`.
+     */
+    total: Money;
+}
+/**
+ * One fully calculated purchase, estimated postpaid usage or recorded order item. Amounts use the
+ * billing-account currency. An item with no immediate charge has zero checkout amounts.
+ */
+export interface QuoteItem {
+    tax_amount: Money;
+    tax_included_amount: Money;
+    /**
+     * Zero-based request line index, or the recorded order item's position for an order quote.
+     * @minimum 0
+     */
+    index: number;
+    /** Present for an existing order quote; identifies the recorded item being priced. */
+    order_item_id?: string;
+    /** The selected price, including when the request identified it indirectly. */
+    price_id: string;
+    plan_name: string;
+    /** Unit price before discounts. Null when no single unit price applies, such as tiered or multiple-rate pricing. */
+    unit_amount: Money | null;
+    /** The quantity priced. When duration_seconds is supplied for metered usage, this is quantity multiplied by that duration. */
+    quantity: string;
+    /** Amount before discounts and including any setup charge. For requested future usage this is an estimate, not a collectible checkout amount. */
+    amount: Money;
+    discount_amount: Money;
+    total: Money;
+    currency: string;
+}
+export type QuotedDiscountType = (typeof QuotedDiscountType)[keyof typeof QuotedDiscountType];
+export declare const QuotedDiscountType: {
+    readonly promotion_code: "promotion_code";
+    readonly account_discount: "account_discount";
+};
+/**
+ * The discount selected for this calculation. Its presence in a quote does not apply it or
+ * reserve a redemption. Discount amounts are reported on the quote and its lines.
+ */
+export interface QuotedDiscount {
+    type: QuotedDiscountType;
+    name: string;
+    /**
+     * Code text for a promotion_code discount; null for an account_discount.
+     * @minLength 1
+     * @maxLength 64
+     * @nullable
+     */
+    promotion_code: string | null;
+}
+/**
+ * Which object this is, together with what a person currently calls it.
+ *
+ * The name is for display. It is chosen by whoever owns the object, it changes, it is not unique
+ * between objects, and it may be empty when nobody has named it yet — so it must not be used to
+ * address, match or deduplicate anything. Addressing is by id.
+ *
+ * This differs from an identity carrying a lookup key: a lookup key is written once by an operator,
+ * is unique, and can be used to fetch the object. A name cannot.
+ */
+export interface NamedIdentity {
+    id: string;
+    /** @maxLength 255 */
+    name: string;
+}
+export type CancellationRefundPreviewItemBillingType = (typeof CancellationRefundPreviewItemBillingType)[keyof typeof CancellationRefundPreviewItemBillingType];
+export declare const CancellationRefundPreviewItemBillingType: {
+    readonly postpaid: "postpaid";
+    readonly prepaid: "prepaid";
+    readonly one_time: "one_time";
+};
+/**
+ * One subscription of the quoted cancellation. The amounts mean what they mean in the total.
+ */
+export interface CancellationRefundPreviewItem {
+    subscription_id: string;
+    plan_id: string;
+    plan_name: string;
+    /**
+     * The project and its current name, for display. Absent for a purchase at account level, and when the
+     * project details cannot be read at the moment.
+     */
+    project?: NamedIdentity | null;
+    billing_type: CancellationRefundPreviewItemBillingType;
+    /**
+     * Whether automatic renewal is on now. Creating the cancellation turns it off, and withdrawing
+     * the cancellation does not turn it back on. Always false for a subscription that is not
+     * `prepaid`.
+     */
+    auto_renew: boolean;
+    unused_amount: Money;
+    refundable_amount: Money;
+    refund_amount: Money;
+    credit_amount: Money;
+    tax_amount: Money;
+    forfeited_amount: Money;
+}
+/**
+ * What the cancellation would return, subscription by subscription and in total, as of now. Give
+ * `proration_date` and `refundable_amount` when creating the cancellation.
+ *
+ * - `unused_amount`: before tax, the amount paid for the current periods minus the value of the
+ *   time used, valued as refund policy `prorated` describes, whatever the refund terms say.
+ * - `refundable_amount`: what is returned the way it was paid, including the tax paid on it;
+ *   `refund_amount` plus `credit_amount`.
+ * - `refund_amount`: the part returned to the balance or to the payment method.
+ * - `credit_amount`: the part restored to the credit grants that paid.
+ * - `tax_amount`: the tax included in `refundable_amount`.
+ * - `forfeited_amount`: before tax, the part of `unused_amount` the refund terms do not return.
+ *
+ * Postpaid and one-time subscriptions show zero; usage until release is charged as usual.
+ */
+export interface CancellationRefundPreview {
+    mode: TerminationPolicy;
+    /** For `period_end`, when release begins, the end of the paid terms. */
+    scheduled_at?: string;
+    /** For `immediate`, the second the refund is computed as of. Give it when creating the cancellation. */
+    proration_date?: string;
+    currency: string;
+    unused_amount: Money;
+    refundable_amount: Money;
+    refund_amount: Money;
+    credit_amount: Money;
+    tax_amount: Money;
+    forfeited_amount: Money;
+    items: CancellationRefundPreviewItem[];
+}
+/**
+ * An estimated refund to original payment sources. Before acceptance, cancellation returns the
+ * collected amount. For delivered service, only value funded by this order is included; renewals
+ * are evaluated under their own orders and the agreed termination terms apply. An unknown
+ * delivery outcome is not evidence that a refund is eligible. This calculation does not create
+ * a refund; the amount returned is determined when cancellation or termination is confirmed.
+ */
+export interface OrderRefundQuote {
+    order_id: string;
+    refundable_amount: Money;
+    refund_amount: Money;
+    credit_amount: Money;
+    currency: string;
+}
+/**
+ * A complete calculation in one billing-account currency, without saving a quote or reserving funds or
+ * redemptions. The request fails if any item cannot be priced. Requested future usage estimates are
+ * included in totals for reporting and are not collectible at checkout. Only an existing-order quote
+ * provides that order's checkout amount.
+ */
+export interface Quote {
+    subtotal: Money;
+    discount_amount: Money;
+    tax_amount: Money;
+    /**
+     * The discount evaluated for a purchase or order, without applying it. Null when none is selected or
+     * when quoting renewals or a cancellation. A confirmed order reports its recorded discount.
+     */
+    discount: QuotedDiscount | null;
+    items: QuoteItem[];
+    renewals: QuoteRenewalResult[];
+    /** What the cancellation requested would return. Present only when one was requested. */
+    cancellation?: CancellationRefundPreview;
+    total: Money;
+    currency: string;
+    /** Present only when an order refund was requested. Nothing is collectible for this target. */
+    refund?: OrderRefundQuote;
+}
+/**
+ * A cancellation to quote: what ending these subscriptions together would return. One mode per
+ * request; to compare, quote `immediate` and `period_end` separately.
+ */
+export interface QuoteCancellation {
+    /**
+     * The subscriptions to end together, all of one service. Every subscription released with a resource must be included.
+     * @minItems 1
+     * @maxItems 50
+     */
+    subscription_ids: string[];
+    mode: TerminationPolicy;
+}
+export interface CancellationCreate {
+    /**
+     * As in the quote.
+     * @minItems 1
+     * @maxItems 50
+     */
+    subscription_ids: string[];
+    mode: TerminationPolicy;
+    /**
+     * For `immediate`, the `proration_date` of the quote: a whole second, not in the future and
+     * at most ten minutes old. The refund is computed as of it. Now when omitted.
+     */
+    proration_date?: string;
+    /** The `refundable_amount` of the quote. The cancellation is refused when the refund differs. */
+    expected_refundable_amount: Money & string;
+    /**
+     * A note from the account holder. It is kept with the cancellation and not shown elsewhere.
+     * @maxLength 1024
+     */
+    reason?: string;
+}
+export type CancellationStatus = (typeof CancellationStatus)[keyof typeof CancellationStatus];
+export declare const CancellationStatus: {
+    readonly requested: "requested";
+    readonly scheduled: "scheduled";
+    readonly releasing: "releasing";
+    readonly completed: "completed";
+    readonly canceled: "canceled";
+    readonly failed: "failed";
+};
+/**
+ * Who asked for it. `project_deletion` means the project was deleted.
+ */
+export type CancellationOrigin = (typeof CancellationOrigin)[keyof typeof CancellationOrigin];
+export declare const CancellationOrigin: {
+    readonly customer: "customer";
+    readonly operator: "operator";
+    readonly project_deletion: "project_deletion";
+};
+/**
+ * How the subscription is paid for. Only a `prepaid` subscription renews automatically; creating
+ * the cancellation turned that off, and withdrawing the cancellation leaves it off.
+ */
+export type CancellationItemBillingType = (typeof CancellationItemBillingType)[keyof typeof CancellationItemBillingType];
+export declare const CancellationItemBillingType: {
+    readonly postpaid: "postpaid";
+    readonly prepaid: "prepaid";
+    readonly one_time: "one_time";
+};
+export type CancellationItemStatus = (typeof CancellationItemStatus)[keyof typeof CancellationItemStatus];
+export declare const CancellationItemStatus: {
+    readonly requested: "requested";
+    readonly scheduled: "scheduled";
+    readonly releasing: "releasing";
+    readonly completed: "completed";
+    readonly canceled: "canceled";
+    readonly failed: "failed";
+};
+/**
+ * One subscription of the cancellation.
+ */
+export interface CancellationItem {
+    /** The cancellation request of this subscription, the same as `Subscription.cancellation_request.id`. */
+    id: string;
+    subscription_id: string;
+    plan_id: string;
+    plan_name: string;
+    /**
+     * How the subscription is paid for. Only a `prepaid` subscription renews automatically; creating
+     * the cancellation turned that off, and withdrawing the cancellation leaves it off.
+     */
+    billing_type: CancellationItemBillingType;
+    status: CancellationItemStatus;
+    release_started_at?: string;
+    /** When the service ended, as confirmed by the service that provides it. */
+    effective_at?: string;
+    /** Present with `completed`. The part of the refund returned to the account balance. */
+    balance_amount?: Money;
+    /** Present with `completed`. The part restored to the credit grants that paid. */
+    credit_amount?: Money;
+    /** Present with `completed`. The part returned to the payment method it was paid with. */
+    gateway_amount?: Money;
+}
+/**
+ * One cancellation of a set of subscriptions of one service, released together at one time.
+ *
+ * - `requested`: `immediate`, release has not begun.
+ * - `scheduled`: `period_end`, waiting for `scheduled_at`.
+ * - `releasing`: release has begun; it can no longer be withdrawn.
+ * - `completed`: every subscription has ended and its refund has been made.
+ * - `canceled`: withdrawn before release began; the subscriptions continue.
+ * - `failed`: the service could not carry it out, for the reason in `failure_code`; the
+ *   subscriptions continue and can be canceled again.
+ */
+export interface Cancellation {
+    id: string;
+    status: CancellationStatus;
+    mode: TerminationPolicy;
+    scheduled_at?: string;
+    /** For `immediate`, the second the refund is computed as of. */
+    proration_date?: string;
+    /** Who asked for it. `project_deletion` means the project was deleted. */
+    origin: CancellationOrigin;
+    /**
+     * The billing account that paid for these subscriptions when the cancellation was created: the
+     * account of an account-level purchase, or the account the project was linked to.
+     */
+    billing_account_id: number;
+    currency: string;
+    /** The refund confirmed when it was created. Absent when the platform created it. */
+    expected_refundable_amount?: Money;
+    /**
+     * Present with `failed`. A code of the service that provides the resources, such as a disk
+     * that can only be released with its server. Clients map it to their own wording.
+     */
+    failure_code?: string;
+    requested_at: string;
+    completed_at?: string;
+    canceled_at?: string;
+    items: CancellationItem[];
+}
+/**
+ * Pagination metadata for stable numbered pages. total_count is returned only when the operation can determine it without an unbounded scan.
+ */
+export interface OffsetPagination {
+    /** @minimum 1 */
+    page: number;
+    /** @minimum 1 */
+    page_size: number;
+    /** @minimum 0 */
+    total_count?: number;
+}
+export interface CancellationList {
+    items: Cancellation[];
+    pagination: OffsetPagination;
+}
+export type CancellationRequestStatus = (typeof CancellationRequestStatus)[keyof typeof CancellationRequestStatus];
+export declare const CancellationRequestStatus: {
+    readonly requested: "requested";
+    readonly scheduled: "scheduled";
+    readonly releasing: "releasing";
+    readonly failed: "failed";
+    readonly completed: "completed";
+    readonly canceled: "canceled";
+};
+export type CancellationRequestMode = (typeof CancellationRequestMode)[keyof typeof CancellationRequestMode];
+export declare const CancellationRequestMode: {
+    readonly immediate: "immediate";
+    readonly period_end: "period_end";
+};
+/**
+ * A cancellation request for the original purchase. scheduled_at is the intended time; effective_at is
+ * the confirmed end of service. The request alone does not stop metering or issue a refund.
+ */
+export interface CancellationRequest {
+    reason?: string;
+    /** The cancellation this request belongs to, with the other subscriptions released together. */
+    cancellation_id?: string;
+    id: string;
+    subscription_id: string;
+    status: CancellationRequestStatus;
+    mode: CancellationRequestMode;
+    requested_at: string;
+    scheduled_at?: string;
+    effective_at?: string;
+    completed_at?: string;
+    release_started_at?: string;
+    canceled_at?: string;
+    forfeit_remaining_value: boolean;
+    failure_code?: string;
+    failure_reason?: string;
+}
+/**
+ * What a given `code` carries alongside the message. The keys depend on the code,
+ * and a client that does not recognise one ignores it.
+ */
+export type ErrorMeta = {
+    [key: string]: unknown;
+};
+export interface Error {
+    code?: string;
+    message: string;
+    /**
+     * What a given `code` carries alongside the message. The keys depend on the code,
+     * and a client that does not recognise one ignores it.
+     */
+    meta?: ErrorMeta;
+    status: number;
+}
+/**
+ * Immutable platform service identifier, such as compute, canopy or assistant.
+ * @minLength 1
+ * @maxLength 64
+ * @pattern ^[a-z][a-z0-9]*(-[a-z0-9]+)*$
+ */
+export type ProductID = string;
+export interface Product {
+    id: ProductID;
+    name: string;
+    description?: string;
+}
+export type BillingAccountStatus = (typeof BillingAccountStatus)[keyof typeof BillingAccountStatus];
+export declare const BillingAccountStatus: {
+    readonly active: "active";
+    readonly suspended: "suspended";
+    readonly closed: "closed";
+};
+export interface BillingAccount {
+    id: number;
+    /** What you call this account. */
+    name?: string;
+    /** The name invoices are made out to. Copied onto each invoice when it is issued. */
+    legal_name?: string;
+    /** Where invoices are sent. */
+    email?: string;
+    address_line1?: string;
+    address_line2?: string;
+    address_city?: string;
+    address_state?: string;
+    address_postal_code?: string;
+    /** Two-letter code. */
+    address_country?: string;
+    tax_id?: string;
+    /** Fixed when the account was opened. */
+    currency: string;
+    status: BillingAccountStatus;
+    /**
+     * How far past the suspension threshold this account may go before its resources are
+     * suspended. "0" means none: the account is suspended as soon as it crosses the threshold.
+     */
+    grace_amount?: string;
+    /**
+     * How long this account has to top up after crossing the suspension threshold.
+     * 0 means none. Whichever runs out first — this or grace_amount — ends the grace.
+     */
+    grace_period_seconds?: number;
+    created_at: string;
+}
+/**
+ * A currency a billing account can be opened in.
+ */
+export interface Currency {
+    /**
+     * ISO 4217 alpha-3, uppercase.
+     * @minLength 3
+     * @maxLength 3
+     */
+    code: string;
+    /**
+     * Decimal places of the currency, the ISO 4217 minor unit.
+     * @minimum 0
+     * @maximum 4
+     */
+    exponent: number;
+    /**
+     * @minLength 1
+     * @maxLength 64
+     */
+    name: string;
+    minimum_top_up: Money;
+}
+export interface CurrencyList {
+    items: Currency[];
+    pagination: OffsetPagination;
+}
+export interface BillingAccountCreate {
+    /**
+     * @minLength 3
+     * @maxLength 3
+     */
+    currency: string;
+    /** @maxLength 255 */
+    name?: string;
+    /** @maxLength 255 */
+    legal_name?: string;
+    /** @maxLength 255 */
+    email?: string;
+}
+export interface BillingAccountUpdate {
+    /** @maxLength 255 */
+    name?: string;
+    /** @maxLength 255 */
+    legal_name?: string;
+    /** @maxLength 255 */
+    email?: string;
+    /** @maxLength 255 */
+    address_line1?: string;
+    /** @maxLength 255 */
+    address_line2?: string;
+    /** @maxLength 128 */
+    address_city?: string;
+    /** @maxLength 128 */
+    address_state?: string;
+    /** @maxLength 32 */
+    address_postal_code?: string;
+    /**
+     * @minLength 2
+     * @maxLength 2
+     */
+    address_country?: string;
+    /** @maxLength 64 */
+    tax_id?: string;
+}
+export interface BillingAccountList {
+    items: BillingAccount[];
+    pagination: OffsetPagination;
+}
+/**
+ * A plan it refers to. active is false once the plan is archived; it still applies to subscriptions already on this plan.
+ */
+export interface ApplicablePlan {
+    id: string;
+    name: string;
+    active: boolean;
+}
+/**
+ * A catalog object inlined for display.
+ */
+export interface ObjectIdentity {
+    lookup_key?: string;
+    id: string;
+    name: string;
+}
+export type PriceOptionBillingScheme = (typeof PriceOptionBillingScheme)[keyof typeof PriceOptionBillingScheme];
+export declare const PriceOptionBillingScheme: {
+    readonly per_unit: "per_unit";
+    readonly tiered: "tiered";
+    readonly rated: "rated";
+};
+export type PriceOptionType = (typeof PriceOptionType)[keyof typeof PriceOptionType];
+export declare const PriceOptionType: {
+    readonly postpaid: "postpaid";
+    readonly prepaid: "prepaid";
+    readonly one_time: "one_time";
+};
+export type PriceOptionInterval = (typeof PriceOptionInterval)[keyof typeof PriceOptionInterval];
+export declare const PriceOptionInterval: {
+    readonly none: "none";
+    readonly day: "day";
+    readonly month: "month";
+    readonly year: "year";
+};
+/**
+ * A price's display terms, including archived prices referenced by an applicability list.
+ */
+export interface PriceOption {
+    product: Product;
+    plan: ObjectIdentity;
+    billing_scheme: PriceOptionBillingScheme;
+    unit_quantity: string;
+    id: string;
+    currency: string;
+    type: PriceOptionType;
+    interval: PriceOptionInterval;
+    /** How many periods one purchase covers. */
+    interval_count?: number;
+    unit_amount?: Money;
+    /** False once the price is archived. It still applies to purchases already made at this price. */
+    active: boolean;
+}
+/**
+ * Which purchase this applies to. `upgrade` and `downgrade` are told apart by money: a change
+ * that costs more for the remainder of the period is an upgrade, one that returns money
+ * is a downgrade. A change that costs neither more nor less is neither.
+ *
+ * `purchase` means a new purchase as opposed to a renewal or a change. It does not mean the
+ * account's first purchase.
+ */
+export type PurchaseOperation = (typeof PurchaseOperation)[keyof typeof PurchaseOperation];
+export declare const PurchaseOperation: {
+    readonly purchase: "purchase";
+    readonly renew: "renew";
+    readonly upgrade: "upgrade";
+    readonly downgrade: "downgrade";
+};
+/**
+ * Anything not excluded that matches an inclusion, or anything not excluded when no inclusion is
+ * given, subject to the billing type, operation and term conditions. Entries always include their
+ * display fields; archived plans and prices stay listed with active set to false.
+ */
+export interface Applicability {
+    products?: Product[];
+    plans?: ApplicablePlan[];
+    prices?: PriceOption[];
+    price_types?: string[];
+    operations?: PurchaseOperation[];
+    /**
+     * The shortest term a purchase may have, in months. A purchase with no term, such as
+     * metered usage, never qualifies while this is set.
+     */
+    min_term_months?: number;
+    /** The longest term a purchase may have, in months. */
+    max_term_months?: number;
+    excluded_products?: Product[];
+    excluded_plans?: ApplicablePlan[];
+    excluded_prices?: PriceOption[];
+}
+export interface CreditGroup {
+    /** What the credit in this group may pay for. No restrictions means anything on the account. */
+    applies_to: Applicability;
+    /** Restricted to your first purchase of anything it applies to. */
+    first_purchase_only?: boolean;
+    amount: Money;
+}
+/**
+ * Account balance, credits, and unpaid charges are reported separately.
+ */
+export interface AccountBalance {
+    billing_account_id: number;
+    currency: string;
+    /**
+     * Prepaid funds in the account currency, excluding credits. May be negative after a payment
+     * dispute. Outstanding charges are reported separately in due; this value is not a withdrawal quote.
+     */
+    balance: Money;
+    /**
+     * The recorded remaining credit, including restricted grants. It is not withdrawable
+     * and is not part of balance. credit_groups describes currently valid credit by permitted use; a positive
+     * credits balance does not imply that due is zero.
+     */
+    credits: Money;
+    /**
+     * balance plus credits, the sum shown as the account's funds. Credits count at their recorded remaining
+     * amount, including restricted grants that only pay for what they allow, so total is an upper bound of what
+     * the account can pay with rather than a withdrawable amount. due is reported separately and is not subtracted.
+     */
+    total: Money;
+    /**
+     * The part of currently valid credit that only pays for what its restrictions allow, such as a single
+     * service, a billing type or a first purchase. The rest of the valid credit pays for anything on the account.
+     * Included in credits and therefore in total.
+     */
+    restricted_credits: Money;
+    /**
+     * Currently valid, unspent credit grouped by permitted use. Restrictions and
+     * validity dates determine which charges a group can cover, so these groups are not a general
+     * spendable balance and may differ from the recorded credits total.
+     */
+    credit_groups: CreditGroup[];
+    /**
+     * Owed and not yet paid: metered usage that balance and applicable credit could not cover as it was
+     * charged, and issued usage invoices still unpaid. The account is in arrears while this
+     * is above zero. Topping up pays it on the next collection.
+     */
+    due: Money;
+}
+export interface MeteredUsage {
+    billing_account_id: number;
+    currency: string;
+    /** Resources still metered in the projects the account currently pays for. */
+    active_resource_count: number;
+    /** Subscriptions billed by usage that the account currently pays for and that have not ended. */
+    postpaid_subscription_count: number;
+    /** The start of the seven days the amounts cover. */
+    window_start: string;
+    /** The end of those seven days, the time usage was last priced. */
+    window_end: string;
+    /** Usage priced in the window, before tax and before credit grants. Usage not yet priced is not included. */
+    amount: Money;
+    /**
+     * `amount` per day. Over the window, or over the part of it since the account's usage began
+     * when that is shorter, counting at least one day.
+     */
+    average_daily_amount: Money;
+}
+/**
+ * A project's assignment to a billing account for the interval from effective_from to effective_to. An open-ended assignment has no end time.
+ */
+export interface ProjectAssignment {
+    project_id: string;
+    /**
+     * The project and its current name, for display. Absent when the project no longer exists or its
+     * details cannot be read at the moment; `project_id` still identifies it.
+     */
+    project?: NamedIdentity | null;
+    billing_account_id: number;
+    account_name?: string;
+    currency: string;
+    effective_from: string;
+    /** @nullable */
+    effective_to?: string | null;
+}
+export interface ProjectAssignmentList {
+    items: ProjectAssignment[];
+    pagination: OffsetPagination;
+}
+export interface SetProjectAssignmentRequest {
+    billing_account_id: number;
+}
+/**
+ * `pending` until the payment gateway reaches a result. The balance increases on `succeeded`.
+ *
+ * `failed` means the gateway declined the payment. A declined attempt ends the top-up at once
+ * and the payment is withdrawn at the gateway; to pay another way, create a new top-up.
+ * `canceled` means the attempt was withdrawn without collecting money; `cancellation_reason`
+ * says why. Unknown gateway outcomes remain `pending`, and a browser redirect is not proof of
+ * payment.
+ *
+ * `failed` and `canceled` are final. If the gateway nevertheless collects payment for such an
+ * attempt, the amount is credited as a separate `succeeded` top-up.
+ */
+export type TopUpStatus = (typeof TopUpStatus)[keyof typeof TopUpStatus];
+export declare const TopUpStatus: {
+    readonly pending: "pending";
+    readonly succeeded: "succeeded";
+    readonly failed: "failed";
+    readonly canceled: "canceled";
+};
+export interface AccountIdentity {
+    id: number;
+    name: string;
+    currency: string;
+}
+/**
+ * Why a gateway payment was withdrawn. `abandoned` means the customer did not complete it within the time
+ * allowed for payment. `requested_by_customer` means the customer canceled it.
+ */
+export type PaymentCancellationReason = (typeof PaymentCancellationReason)[keyof typeof PaymentCancellationReason];
+export declare const PaymentCancellationReason: {
+    readonly abandoned: "abandoned";
+    readonly requested_by_customer: "requested_by_customer";
+};
+export type PaymentActionType = (typeof PaymentActionType)[keyof typeof PaymentActionType];
+export declare const PaymentActionType: {
+    readonly redirect: "redirect";
+    readonly qr_code: "qr_code";
+    readonly sdk: "sdk";
+};
+/**
+ * The customer's next interaction. The gateway reports the actual payment outcome separately.
+ */
+export interface PaymentAction {
+    type: PaymentActionType;
+    /** Identifies the browser adapter for an SDK action, for example stripe. */
+    provider?: string;
+    url?: string;
+    /** QR content to render and scan, not an image URL. */
+    qr_code?: string;
+    /** Short-lived client credential for this payment's browser confirmation. */
+    client_secret?: string;
+    public_key?: string;
+}
+/**
+ * A top-up attempt and its outcome. A successful top-up adds a traceable amount to the balance; it is not a credit grant and has no associated invoice.
+ */
+export interface TopUp {
+    id: string;
+    billing_account_id: number;
+    account: AccountIdentity;
+    /** What is credited to the account, in the account's own currency. */
+    amount: Money;
+    currency: string;
+    /**
+     * The part of this top-up still held in the balance. Pending refunds and payouts can temporarily
+     * reserve part of it; it is not a promise that the whole amount is immediately withdrawable.
+     */
+    remaining_amount?: Money;
+    /**
+     * `pending` until the payment gateway reaches a result. The balance increases on `succeeded`.
+     *
+     * `failed` means the gateway declined the payment. A declined attempt ends the top-up at once
+     * and the payment is withdrawn at the gateway; to pay another way, create a new top-up.
+     * `canceled` means the attempt was withdrawn without collecting money; `cancellation_reason`
+     * says why. Unknown gateway outcomes remain `pending`, and a browser redirect is not proof of
+     * payment.
+     *
+     * `failed` and `canceled` are final. If the gateway nevertheless collects payment for such an
+     * attempt, the amount is credited as a separate `succeeded` top-up.
+     */
+    status: TopUpStatus;
+    cancellation_reason?: PaymentCancellationReason;
+    /** Which payment gateway collected it. */
+    payment_gateway?: string;
+    /** The selected payment method, such as card, wechat_pay or alipay. */
+    method_type?: string;
+    /**
+     * The currency the customer was actually charged in, when the checkout page collected a
+     * local one. Absent when it was the same as the account's.
+     */
+    presentment_currency?: string;
+    /**
+     * What was charged, in `presentment_currency`. It will not equal `amount`, and it is
+     * the figure that appears on the customer's card or wallet statement.
+     */
+    presentment_amount?: Money;
+    /**
+     * Why the gateway declined it. Present with `failed`. The value is the gateway's own code,
+     * passed on unchanged: the card issuer's decline code when there is one (Stripe's decline_code,
+     * such as insufficient_funds or lost_card), otherwise the gateway's error code (Stripe's code,
+     * such as card_declined, expired_card or payment_intent_authentication_failure). Clients map it
+     * to their own wording and treat an unknown value as a generic decline.
+     */
+    failure_reason?: string;
+    action?: PaymentAction;
+    created_at: string;
+    /**
+     * When the funds arrived. Later than `created_at` — by days for a bank transfer — so
+     * reconciling against a statement uses this rather than the moment it was started.
+     * Absent until the payment completes.
+     * @nullable
+     */
+    settled_at?: string | null;
+}
+export interface TopUpCreate {
+    /**
+     * The gateway explicitly selected from the available payment options.
+     * @minLength 1
+     * @maxLength 32
+     */
+    payment_gateway: string;
+    /**
+     * The selected method, such as card, wechat_pay or alipay.
+     * @minLength 1
+     * @maxLength 64
+     */
+    method_type: string;
+    /** The ID of this top-up attempt. Keep it before submitting and query it after an uncertain response. */
+    id: string;
+    billing_account_id: number;
+    /**
+     * In the account's currency, and no finer than that currency's smallest unit:
+     * two decimals for most, none for the yen. A finer amount is refused here rather
+     * than at the checkout page, where the customer would see the gateway's own wording
+     * instead of an explanation.
+     *
+     * There is a minimum, which differs by currency. Below it the gateway's fee
+     * exceeds the top-up itself, so such a payment costs more to accept than it brings.
+     * The minimum in force is returned with the rejection.
+     */
+    amount: Money & string;
+    /** Charge a saved method instead of opening a checkout page. */
+    payment_method_id?: string;
+    /** Where to send the customer after checkout. */
+    return_url?: string;
+}
+export interface TopUpList {
+    items: TopUp[];
+    pagination: OffsetPagination;
+}
+export interface PaymentOptionMethod {
+    /** The value to send as `method_type`, such as card, wechat_pay or alipay. */
+    method_type: string;
+    /**
+     * Whether a method of this type can be saved with create-payment-method-setup and charged later
+     * without the customer present. Methods that are not reusable are paid anew each time.
+     */
+    reusable: boolean;
+}
+/**
+ * A payment gateway that accepts payment in the account's currency, with the methods it accepts.
+ */
+export interface PaymentOption {
+    /** The value to send as `payment_gateway`. */
+    payment_gateway: string;
+    methods: PaymentOptionMethod[];
+}
+export interface PaymentOptionList {
+    items: PaymentOption[];
+    pagination: OffsetPagination;
+}
+export type PaymentMethodStatus = (typeof PaymentMethodStatus)[keyof typeof PaymentMethodStatus];
+export declare const PaymentMethodStatus: {
+    readonly active: "active";
+    readonly expired: "expired";
+    readonly removed: "removed";
+};
+export interface PaymentMethod {
+    id: string;
+    billing_account_id: number;
+    payment_gateway: string;
+    brand?: string;
+    last4?: string;
+    /** @nullable */
+    exp_month?: number | null;
+    /** @nullable */
+    exp_year?: number | null;
+    is_default: boolean;
+    status: PaymentMethodStatus;
+}
+export interface PaymentMethodList {
+    items: PaymentMethod[];
+    pagination: OffsetPagination;
+}
+export interface PaymentMethodSetup {
+    /**
+     * The selected gateway supporting saved payment methods.
+     * @minLength 1
+     * @maxLength 32
+     */
+    payment_gateway: string;
+    billing_account_id: number;
+}
+/**
+ * What the payment gateway's browser library needs in order to collect a card. There is
+ * no address to redirect to: the form is rendered in the page, and the card goes straight
+ * from the browser to the gateway.
+ */
+export interface PaymentMethodSetupResult {
+    /**
+     * The gateway's identifier for this attempt. Use it to tell a reloaded page apart
+     * from a second attempt.
+     */
+    setup_id: string;
+    payment_gateway: string;
+    action: PaymentAction;
+}
+/**
+ * Applies eligible credit grants and the available balance as requested, then collects only the remainder
+ * through the selected gateway. Grants restricted to other purchases are not counted as available funds.
+ * An unresolved channel payment is reused; retries do not apply the grant or balance portions twice.
+ * Without a gateway selection, insufficient account funds fail without starting an online payment.
+ */
+export interface PayInvoiceRequest {
+    /**
+     * Required to collect an online remainder. An existing attempt keeps its original gateway.
+     * @minLength 1
+     * @maxLength 32
+     */
+    payment_gateway?: string;
+    /**
+     * Required with payment_gateway; for example card, wechat_pay or alipay.
+     * @minLength 1
+     * @maxLength 64
+     */
+    method_type?: string;
+    /** Optional saved card owned by this billing account and belonging to the selected gateway. Omit to complete payment interactively. */
+    payment_method_id?: string;
+    /** Whether to apply the available balance. Credit grants are controlled separately by use_credits. */
+    use_balance?: boolean;
+    /** Apply eligible, unexpired credit grants before using the balance. This never withdraws grants or converts them into balance. */
+    use_credits?: boolean;
+    return_url?: string;
+}
+/**
+ * Name at least one invoice or order. They must all belong to the same account and share
+ * its currency; anything else is refused rather than partly paid.
+ */
+export interface PayTogetherRequest {
+    /** @maxItems 100 */
+    invoice_ids?: string[];
+    /** @maxItems 100 */
+    order_ids?: string[];
+}
+/**
+ * The current payment outcome.
+ *
+ * succeeded means payment is complete. processing means confirmation is pending; poll the invoice or
+ * order rather than submitting another payment. requires_action means the customer must complete the
+ * supplied action. failed means the attempt did not succeed and failure_reason explains the outcome; a
+ * declined gateway payment is withdrawn at the gateway, and paying again starts a new payment with the
+ * same or another method.
+ */
+export type PaymentStatus = (typeof PaymentStatus)[keyof typeof PaymentStatus];
+export declare const PaymentStatus: {
+    readonly succeeded: "succeeded";
+    readonly processing: "processing";
+    readonly requires_action: "requires_action";
+    readonly failed: "failed";
+};
+/**
+ * A credit grant and what it would pay.
+ */
+export interface AppliedCredit {
+    credit_grant_id: string;
+    name: string;
+    amount: Money;
+}
+export interface PaymentPreviewInvoice {
+    invoice_id: string;
+    /** @nullable */
+    order_id?: string | null;
+    amount_due: Money;
+    credit_applied: Money;
+    balance_applied: Money;
+}
+/**
+ * What paying would take, computed as paying computes it. Nothing is charged or reserved.
+ */
+export interface PaymentPreview {
+    currency: string;
+    /** What is outstanding before paying. */
+    amount_due: Money;
+    /** What credit grants would pay. Grants restricted to other purchases pay nothing here. */
+    credit_applied: Money;
+    /** The credit grants that would pay, in the order they would be used. */
+    credit_grants: AppliedCredit[];
+    /** What the balance would pay. */
+    balance_applied: Money;
+    /** What would remain to be paid online. Paying without a gateway is refused with `BILLING_INSUFFICIENT_FUNDS` while this is above zero. */
+    gateway_amount: Money;
+    /** The available balance after paying. */
+    balance_after: Money;
+    /** Paying together only. Each invoice, in the order it would be paid. */
+    invoices?: PaymentPreviewInvoice[];
+}
+/**
+ * Present on refunds. Where this part of the refund goes.
+ *
+ * - `balance`: back to the account balance.
+ * - `credit`: back to the credit grant that paid, which keeps its original expiry.
+ * - `gateway`: back to the payment method it was paid with.
+ */
+export type TransactionRefundDestination = (typeof TransactionRefundDestination)[keyof typeof TransactionRefundDestination];
+export declare const TransactionRefundDestination: {
+    readonly balance: "balance";
+    readonly credit: "credit";
+    readonly gateway: "gateway";
+};
+/**
+ * `failed` means the operation did not succeed; for a gateway payment, that the gateway declined
+ * it. `canceled` means a gateway payment was withdrawn without collecting money. After either,
+ * an invoice the payment was meant to pay remains open for another payment.
+ */
+export type TransactionStatus = (typeof TransactionStatus)[keyof typeof TransactionStatus];
+export declare const TransactionStatus: {
+    readonly pending: "pending";
+    readonly succeeded: "succeeded";
+    readonly failed: "failed";
+    readonly canceled: "canceled";
+};
+/**
+ * topup adds to the balance; payment settles an invoice; refund returns original funds; payout withdraws from the balance; adjustment changes the balance with an audit reason.
+ */
+export type TransactionType = (typeof TransactionType)[keyof typeof TransactionType];
+export declare const TransactionType: {
+    readonly topup: "topup";
+    readonly payment: "payment";
+    readonly refund: "refund";
+    readonly payout: "payout";
+    readonly adjustment: "adjustment";
+};
+/**
+ * A funds operation. Each payment has one source; refunds identify the original successful transaction. Unknown gateway results remain pending. Payments from the balance or a gateway are distinct from credit-grant payments.
+ */
+export interface Transaction {
+    invoice_id?: string;
+    transaction_id?: string;
+    /** The credit grant that paid, or for a refund, the credit grant restored. */
+    credit_grant_id?: string;
+    credit_grant?: ObjectIdentity;
+    refund_id?: string;
+    /**
+     * Present on refunds. Where this part of the refund goes.
+     *
+     * - `balance`: back to the account balance.
+     * - `credit`: back to the credit grant that paid, which keeps its original expiry.
+     * - `gateway`: back to the payment method it was paid with.
+     */
+    refund_destination?: TransactionRefundDestination;
+    /**
+     * `failed` means the operation did not succeed; for a gateway payment, that the gateway declined
+     * it. `canceled` means a gateway payment was withdrawn without collecting money. After either,
+     * an invoice the payment was meant to pay remains open for another payment.
+     */
+    status?: TransactionStatus;
+    cancellation_reason?: PaymentCancellationReason;
+    payment_gateway?: string;
+    method_type?: string;
+    /**
+     * Why it failed. Present with `failed`. For a declined gateway payment the value is the
+     * gateway's own code, passed on unchanged: the card issuer's decline code when there is one
+     * (Stripe's decline_code, such as insufficient_funds or lost_card), otherwise the gateway's
+     * error code (Stripe's code, such as card_declined, expired_card or
+     * payment_intent_authentication_failure). Clients map it to their own wording and treat an
+     * unknown value as a generic decline.
+     */
+    failure_reason?: string;
+    settled_at?: string;
+    id: string;
+    billing_account_id?: number;
+    type: TransactionType;
+    /**
+     * Signed by type: positive for `topup` and `payment`, negative for `refund` and `payout`.
+     * An `adjustment` is positive when it adds to the balance and negative when it takes from
+     * it. For the other types the sign does not tell the effect on the balance: a payment from
+     * the balance lowers it, while a payment by gateway or by credit leaves it unchanged.
+     */
+    amount: Money;
+    /**
+     * How much of this transaction is still available in the balance. Only top-ups, positive
+     * adjustments and gateway payments later returned to the balance can be non-zero.
+     */
+    remaining_amount: Money;
+    currency: string;
+    reason?: string;
+    created_at: string;
+}
+export interface PaymentResult {
+    transactions: Transaction[];
+    /** The gateway transaction, when one is involved. Balance and credit-grant payments are separate transactions. */
+    transaction_id?: string;
+    status: PaymentStatus;
+    amount_paid: Money;
+    /**
+     * What is still outstanding. Zero once the payment succeeds. Unchanged while
+     * `processing`: nothing is collected until the gateway confirms it.
+     */
+    amount_due: Money;
+    currency: string;
+    credit_applied?: Money;
+    gateway_amount?: Money;
+    payment_gateway?: string;
+    method_type?: string;
+    /**
+     * The amount already paid from the account's balance toward this invoice. Retrying an online remainder
+     * does not debit it again. A canceled purchase returns funds through its refund process.
+     */
+    balance_applied?: Money;
+    action?: PaymentAction;
+    /**
+     * Whether paying again is worth attempting. False for a refusal that will keep
+     * happening — a closed account, an amount over a limit — so that a client does not
+     * retry in a loop.
+     */
+    retriable?: boolean;
+    /** @nullable */
+    invoice_id?: string | null;
+    /** @nullable */
+    order_id?: string | null;
+    /**
+     * Why the payment did not go through. Present with `failed`. For a declined gateway payment the
+     * value is the gateway's own code, passed on unchanged: the card issuer's decline code when
+     * there is one (Stripe's decline_code, such as insufficient_funds or lost_card), otherwise the
+     * gateway's error code (Stripe's code, such as card_declined, expired_card or
+     * payment_intent_authentication_failure). Clients map it to their own wording and treat an
+     * unknown value as a generic decline.
+     */
+    failure_reason?: string;
+}
+/**
+ * An order invoice stays `draft` until checkout confirms its discount and final amounts. It
+ * cannot be collected while draft. Confirmation makes it `open`, or `paid` when its total is zero
+ * without creating a payment transaction. A quote never changes this status.
+ *
+ * A usage invoice stays `draft` through its month: each charge is added to it as it is priced
+ * and paid from credits and balance as it goes. It is issued at the end of the month, becoming
+ * `paid` when everything was covered and `open` when something is still owed.
+ *
+ * `refunded` means the invoice was paid and has since been refunded in full; a partial refund
+ * leaves it `paid`, with the refunded part in `amount_refunded`.
+ *
+ * `void` means the invoice will not be paid and holds no money: nothing was paid, or its order
+ * failed or was canceled and everything paid toward it has been returned, as `amount_paid` and
+ * `amount_refunded` show.
+ */
+export type InvoiceStatus = (typeof InvoiceStatus)[keyof typeof InvoiceStatus];
+export declare const InvoiceStatus: {
+    readonly draft: "draft";
+    readonly open: "open";
+    readonly paid: "paid";
+    readonly refunded: "refunded";
+    readonly void: "void";
+    readonly uncollectible: "uncollectible";
+};
+/**
+ * What produced it — metered usage for a period, a purchase, or a correction.
+ */
+export type InvoiceType = (typeof InvoiceType)[keyof typeof InvoiceType];
+export declare const InvoiceType: {
+    readonly usage: "usage";
+    readonly order: "order";
+    readonly adjustment: "adjustment";
+};
+/**
+ * Tax name, rate and amounts frozen on the invoice.
+ */
+export interface TaxItem {
+    id: string;
+    invoice_id: string;
+    name: string;
+    percentage: string;
+    country: string;
+    state?: string;
+    taxable_amount: string;
+    tax_amount: string;
+    currency: string;
+}
+export interface Invoice {
+    due_at?: string;
+    amount_refunded?: string;
+    tax_items: TaxItem[];
+    /** The purchase that produced this invoice. Absent on usage invoices. */
+    order_id?: string;
+    id: string;
+    billing_account_id: number;
+    /** Numbered per account and per month. */
+    number: string;
+    /** What produced it — metered usage for a period, a purchase, or a correction. */
+    type?: InvoiceType;
+    currency: string;
+    status: InvoiceStatus;
+    /**
+     * Sum of the line amounts before discounts. Where prices include tax, the tax contained in
+     * each line's discounted amount is taken out here, so that total = subtotal -
+     * discount_amount + tax_amount always holds.
+     */
+    subtotal?: Money;
+    /** Sum of the line discounts, taken off before tax. */
+    discount_amount?: Money;
+    tax_amount?: Money;
+    /** Successful credit-grant payments included in amount_paid. Does not reduce the receivable or tax base. */
+    credit_applied?: Money;
+    /** Subtotal less discount plus tax. Balance and credit grants are payment sources, not reductions of the receivable. */
+    total: Money;
+    amount_paid?: Money;
+    /** What is still collectible after applied credits and successful payments; never below zero. A draft order invoice is not collectible until checkout confirms it, and a paid or void invoice has none. */
+    amount_due: Money;
+    /** @nullable */
+    period_start?: string | null;
+    /**
+     * Exclusive.
+     * @nullable
+     */
+    period_end?: string | null;
+    /**
+     * Who this was billed to, as recorded when the invoice was issued. Later changes to
+     * the account do not alter it.
+     */
+    customer_name?: string;
+    customer_email?: string;
+    customer_tax_id?: string;
+    customer_address_line1?: string;
+    customer_address_line2?: string;
+    customer_address_city?: string;
+    customer_address_state?: string;
+    customer_address_postal_code?: string;
+    customer_address_country?: string;
+    /** @nullable */
+    paid_at?: string | null;
+}
+export interface InvoiceList {
+    items: Invoice[];
+    pagination: OffsetPagination;
+}
+export type InvoiceItemType = (typeof InvoiceItemType)[keyof typeof InvoiceItemType];
+export declare const InvoiceItemType: {
+    readonly usage: "usage";
+    readonly subscription: "subscription";
+    readonly one_time: "one_time";
+    readonly setup: "setup";
+    readonly adjustment: "adjustment";
+};
+export interface InvoiceItem {
+    recurring_amount?: string;
+    taxable?: boolean;
+    /** Discount applied to this line before tax. */
+    discount_amount?: string;
+    /** Tax on the discounted line, including tax already included in the price. */
+    tax_amount?: string;
+    /** The part of tax_amount already included in amount. */
+    tax_included_amount?: string;
+    /** The original order line. Refunds follow that line's original payment sources. */
+    order_item_id?: string;
+    id: string;
+    type?: InvoiceItemType;
+    /** @nullable */
+    project_id?: string | null;
+    /**
+     * The project the charge was for and its current name, for display. Absent when the line is
+     * not for a project, and when the project no longer exists or its details cannot be read at
+     * the moment; `project_id` still identifies it then.
+     */
+    project?: NamedIdentity | null;
+    resource_id?: string;
+    /**
+     * The wording as recorded when the invoice was issued. It is not re-translated
+     * afterwards, so that an invoice continues to read as it did when it was sent.
+     */
+    description: string;
+    unit?: string;
+    quantity?: string;
+    /** The part covered by an included allowance, and therefore not charged. */
+    deducted_quantity?: string;
+    unit_amount?: Money;
+    amount: Money;
+    currency: string;
+    /** @nullable */
+    period_start?: string | null;
+    /** @nullable */
+    period_end?: string | null;
+}
+export interface InvoiceItemList {
+    items: InvoiceItem[];
+    pagination: OffsetPagination;
+}
+export interface TransactionList {
+    items: Transaction[];
+    pagination: OffsetPagination;
+}
+export type CreditGrantStatus = (typeof CreditGrantStatus)[keyof typeof CreditGrantStatus];
+export declare const CreditGrantStatus: {
+    readonly active: "active";
+    readonly depleted: "depleted";
+    readonly expired: "expired";
+    readonly voided: "voided";
+};
+export interface CreditGrant {
+    min_amount?: string;
+    id: string;
+    billing_account_id?: number;
+    name: string;
+    amount: Money;
+    remaining_amount: Money;
+    currency: string;
+    /** What this credit may pay for. No restrictions means anything on the account. */
+    applies_to: Applicability;
+    /** Restricted to your first purchase of anything it applies to. */
+    first_purchase_only?: boolean;
+    status: CreditGrantStatus;
+    valid_from: string;
+    /** @nullable */
+    valid_until?: string | null;
+}
+export interface CreditGrantList {
+    items: CreditGrant[];
+    pagination: OffsetPagination;
+}
+/**
+ * Use balance_amount, credit_amount and gateway_amount, which also show a refund split between several destinations.
+ * @deprecated
+ */
+export type RefundDestination = (typeof RefundDestination)[keyof typeof RefundDestination];
+export declare const RefundDestination: {
+    readonly balance: "balance";
+    readonly gateway: "gateway";
+};
+/**
+ * Summary of the parts in `transactions`.
+ *
+ * - `pending`: nothing has been returned yet, and at least one part is in progress.
+ * - `processing`: some parts have been returned, and at least one is still in progress.
+ * - `succeeded`: every part has been returned.
+ * - `failed`: no part is in progress and at least one has failed. What was returned is in
+ *   settled_amount.
+ *
+ * Returns to the balance and to credit grants complete shortly after the refund is made; a
+ * return to a payment method completes when the gateway confirms it.
+ */
+export type RefundStatus = (typeof RefundStatus)[keyof typeof RefundStatus];
+export declare const RefundStatus: {
+    readonly pending: "pending";
+    readonly processing: "processing";
+    readonly succeeded: "succeeded";
+    readonly failed: "failed";
+};
+/**
+ * Why the refund was made. Clients map the code to their own wording. More codes may be added;
+ * treat an unknown code as a refund without a stated reason.
+ *
+ * - `provisioning_failed`: the purchase could not be delivered.
+ * - `order_expired`: the order expired after part of it had been paid.
+ * - `order_canceled`: the account holder canceled the order after part of it had been paid.
+ * - `change_canceled`: a scheduled change was withdrawn after part of it had been paid.
+ * - `change_expired`: a scheduled change could not take effect before its time passed.
+ * - `subscription_canceled`: the subscription was canceled and its unused value returned under
+ *   its refund terms.
+ * - `future_period_canceled`: a renewal that had not started yet was withdrawn.
+ * - `downgrade_difference`: after a downgrade, the remaining value of what was paid, valued as refund
+ *   policy `prorated` describes, minus the new configuration's cost for the remaining time at the
+ *   change item's `refund_monthly_amount` and `refund_hourly_amount`. Nothing is refunded when that is
+ *   zero or less.
+ * - `usage_true_up`: usage priced again over the whole month cost less than was charged.
+ * - `payment_not_applied`: a payment arrived after its invoice could no longer be paid.
+ * - `operator`: made by the platform operator.
+ */
+export type RefundReason = (typeof RefundReason)[keyof typeof RefundReason];
+export declare const RefundReason: {
+    readonly provisioning_failed: "provisioning_failed";
+    readonly order_expired: "order_expired";
+    readonly order_canceled: "order_canceled";
+    readonly change_canceled: "change_canceled";
+    readonly change_expired: "change_expired";
+    readonly subscription_canceled: "subscription_canceled";
+    readonly future_period_canceled: "future_period_canceled";
+    readonly downgrade_difference: "downgrade_difference";
+    readonly usage_true_up: "usage_true_up";
+    readonly payment_not_applied: "payment_not_applied";
+    readonly operator: "operator";
+};
+export interface Refund {
+    transaction_id?: string;
+    cancellation_request_id?: string;
+    /** Original funds-return split and each result. Unknown gateway results remain pending. */
+    transactions: Transaction[];
+    id: string;
+    billing_account_id?: number;
+    /** @nullable */
+    invoice_id?: string | null;
+    /**
+     * The order the refund belongs to: the order that caused it, such as a downgrade, otherwise
+     * the order of the refunded invoice. Null for refunds of top-ups and of usage invoices.
+     * @nullable
+     */
+    order_id?: string | null;
+    /** The whole refund. Equals balance_amount plus credit_amount plus gateway_amount. */
+    amount: Money;
+    /** The part returned to the account balance. */
+    balance_amount: Money;
+    /** The part restored to the credit grants that paid for it. */
+    credit_amount: Money;
+    /** The part returned to the payment method it was paid with. */
+    gateway_amount: Money;
+    /** What has actually been returned. */
+    settled_amount?: Money;
+    currency: string;
+    /**
+     * Use balance_amount, credit_amount and gateway_amount, which also show a refund split between several destinations.
+     * @deprecated
+     */
+    destination?: RefundDestination;
+    /**
+     * Summary of the parts in `transactions`.
+     *
+     * - `pending`: nothing has been returned yet, and at least one part is in progress.
+     * - `processing`: some parts have been returned, and at least one is still in progress.
+     * - `succeeded`: every part has been returned.
+     * - `failed`: no part is in progress and at least one has failed. What was returned is in
+     *   settled_amount.
+     *
+     * Returns to the balance and to credit grants complete shortly after the refund is made; a
+     * return to a payment method completes when the gateway confirms it.
+     */
+    status: RefundStatus;
+    /** When the last part was returned. Present with `succeeded`. */
+    settled_at?: string;
+    reason: RefundReason;
+    created_at: string;
+}
+export interface RefundList {
+    items: Refund[];
+    pagination: OffsetPagination;
+}
+/**
+ * The attributes the rate was chosen by, such as region and machine type.
+ */
+export type UsageChargeDimensions = {
+    [key: string]: string;
+};
+export interface UsageCharge {
+    subscription_id?: string;
+    id: string;
+    project_id?: string;
+    /**
+     * The project and its current name, for display. Absent when the project no longer exists or its
+     * details cannot be read at the moment; `project_id` still identifies it.
+     */
+    project?: NamedIdentity | null;
+    product: Product;
+    /** Which resource this was charged for. Empty for charges not tied to one. */
+    resource_id?: string;
+    meter: ObjectIdentity;
+    unit?: string;
+    /** The attributes the rate was chosen by, such as region and machine type. */
+    dimensions?: UsageChargeDimensions;
+    window_start: string;
+    /** Exclusive. */
+    window_end: string;
+    /** How much was used, before any included allowance. */
+    gross_quantity?: string;
+    /** How much of that was covered by an allowance. */
+    deducted_quantity?: string;
+    /** What was charged for — the gross quantity less the part covered. */
+    quantity: string;
+    unit_amount?: Money;
+    amount?: Money;
+    currency: string;
+    /**
+     * The usage invoice this charge was added to. Absent while it waits to be priced.
+     * @nullable
+     */
+    invoice_id?: string | null;
+    /**
+     * The usage invoice line this charge was summed into. Absent while it waits to be priced.
+     * @nullable
+     */
+    invoice_item_id?: string | null;
+}
+export interface UsageChargeList {
+    items: UsageCharge[];
+    pagination: OffsetPagination;
+}
+export type SubscriptionBillingType = (typeof SubscriptionBillingType)[keyof typeof SubscriptionBillingType];
+export declare const SubscriptionBillingType: {
+    readonly postpaid: "postpaid";
+    readonly prepaid: "prepaid";
+    readonly one_time: "one_time";
+};
+export type SubscriptionInterval = (typeof SubscriptionInterval)[keyof typeof SubscriptionInterval];
+export declare const SubscriptionInterval: {
+    readonly none: "none";
+    readonly day: "day";
+    readonly month: "month";
+    readonly year: "year";
+};
+/**
+ * How it was paid, as recorded at the time. It is kept as it was: removing the card afterwards
+ * does not change it, and `payment_method_id` may then name a card that no longer exists.
+ */
+export interface PaidWith {
+    /**
+     * `balance` when the account's balance and credits covered it in full. Otherwise the method used
+     * with the gateway, such as `card`.
+     */
+    method_type: string;
+    /** The gateway that collected it. Absent when `method_type` is `balance`. */
+    payment_gateway?: string;
+    /** The saved payment method that was charged, when one was. */
+    payment_method_id?: string;
+    brand?: string;
+    last4?: string;
+}
+/**
+ * pending means the purchase relationship exists but its order has not been accepted.
+ * provisioning means the service accepted the order and is delivering. For a service-owned
+ * purchase, only confirmed delivery moves it to active; paying alone does not.
+ */
+export type SubscriptionStatus = (typeof SubscriptionStatus)[keyof typeof SubscriptionStatus];
+export declare const SubscriptionStatus: {
+    readonly pending: "pending";
+    readonly provisioning: "provisioning";
+    readonly active: "active";
+    readonly suspended: "suspended";
+    readonly canceled: "canceled";
+    readonly terminated: "terminated";
+};
+/**
+ * An independently billed purchase relationship, separate from the owning service's resource.
+ * Placing a new prepaid or postpaid service order creates a pending subscription for each line
+ * in the same purchase transaction. Its ID is returned on the order item and remains stable
+ * through checkout and delivery. One order may create several subscriptions, such as an instance,
+ * its system disk and its address; it has no single subscription ID.
+ *
+ * Pending and provisioning do not grant service or accrue usage. A service-owned subscription
+ * becomes provisioning when the owning service accepts the order, and active when the service
+ * confirms delivery, with started_at set to the confirmed effective time; payment changes neither. Prepaid service periods start
+ * then; postpaid usage starts only when the service reports actual delivery and metering.
+ *
+ * One-time delivery may omit a subscription. Renewals reference and extend existing subscriptions
+ * rather than creating another; a change keeps the subscription ID and switches its terms when it
+ * takes effect. Canceling or failing an
+ * unfulfilled purchase closes its pending or provisioning subscriptions without starting a service period.
+ * Fixed renewals use the agreed recurring_amount and interval; already paid periods retain their
+ * original value. Technical state belongs to the owning service.
+ *
+ * A purchased shared capacity limit, such as a regional snapshot count quota, can have its own
+ * subscription. Activating that capacity confirms delivery of the quota, not individual snapshots.
+ * Creating or deleting snapshots within it does not create, activate or terminate more subscriptions;
+ * the owning service enforces current holdings against the purchased count.
+ */
+export interface Subscription {
+    currency: string;
+    billing_type: SubscriptionBillingType;
+    interval: SubscriptionInterval;
+    /** @minimum 1 */
+    interval_count?: number;
+    /**
+     * Whole-subscription prepaid renewal amount, after continuing discounts and before tax.
+     * Pending subscriptions show base terms until checkout confirms any new continuing discount.
+     * Absent for other billing types.
+     */
+    recurring_amount?: string;
+    termination_policy?: TerminationPolicy;
+    refund_policy?: RefundPolicy;
+    order_item_id?: string;
+    /** Present only on subscriptions created by an earlier change that replaced the subscription. A change now keeps the subscription ID. */
+    replaces_subscription_id?: string;
+    coupon_id?: string;
+    coupon?: ObjectIdentity;
+    /** @minimum 0 */
+    discounted_renewals_remaining?: number;
+    suspend_reason?: string;
+    billing_cycle_anchor?: string;
+    cancellation_request?: CancellationRequest;
+    /**
+     * How the purchase, or the latest renewal paid with a saved card, was paid. Automatic renewal
+     * tries this card after the account's balance and credits, and the account's default card after
+     * that.
+     */
+    paid_with?: PaidWith;
+    created_at?: string;
+    id: string;
+    /** The billing account that made the purchase. Renewals of a project subscription are charged to the project's current billing account. */
+    billing_account_id: number;
+    account: AccountIdentity;
+    product_id: ProductID;
+    /**
+     * Which project this is for. Absent when it was bought at account level, such as a
+     * membership, which belongs to no single project.
+     * @nullable
+     */
+    project_id?: string | null;
+    /**
+     * The project and its current name, for display. Absent for a purchase at account level,
+     * and when the project no longer exists or its details cannot be read at the moment;
+     * `project_id` still identifies it then.
+     */
+    project?: NamedIdentity | null;
+    product: Product;
+    plan_id: string;
+    plan_name: string;
+    price_id: string;
+    quantity: string;
+    /**
+     * End of the prepaid service already activated. Null until a new subscription becomes active,
+     * even when its purchase has been paid, and for postpaid subscriptions with no prepaid end date.
+     * @nullable
+     */
+    paid_until?: string | null;
+    auto_renew: boolean;
+    /**
+     * pending means the purchase relationship exists but its order has not been accepted.
+     * provisioning means the service accepted the order and is delivering. For a service-owned
+     * purchase, only confirmed delivery moves it to active; paying alone does not.
+     */
+    status: SubscriptionStatus;
+    /**
+     * Confirmed start of service. Null until a new subscription becomes active, including after payment.
+     * @nullable
+     */
+    started_at?: string | null;
+    /** @nullable */
+    ended_at?: string | null;
+}
+export interface SubscriptionList {
+    items: Subscription[];
+    pagination: OffsetPagination;
+}
+export type RenewalPriceInterval = (typeof RenewalPriceInterval)[keyof typeof RenewalPriceInterval];
+export declare const RenewalPriceInterval: {
+    readonly day: "day";
+    readonly month: "month";
+    readonly year: "year";
+};
+export interface RenewalPrice {
+    termination_policy?: TerminationPolicy;
+    refund_policy?: RefundPolicy;
+    price_id: string;
+    /** How many periods one renewal covers. */
+    interval_count: number;
+    interval: RenewalPriceInterval;
+    /** What renewing for this term costs, for the quantity held. */
+    amount?: Money;
+    currency?: string;
+    /**
+     * The term this item already bills at. Renewing for it uses the price bought
+     * originally, so a later price change does not affect it.
+     */
+    current: boolean;
+}
+export interface RenewalPriceList {
+    items: RenewalPrice[];
+    pagination: OffsetPagination;
+}
+/**
+ * The unit interval_count counts in.
+ */
+export type RenewRequestInterval = (typeof RenewRequestInterval)[keyof typeof RenewRequestInterval];
+export declare const RenewRequestInterval: {
+    readonly day: "day";
+    readonly month: "month";
+    readonly year: "year";
+};
+export interface RenewRequest {
+    /** Purchase ID saved before submitting. Duplicate creation conflicts; query this order after an unknown result. */
+    order_id: string;
+    /**
+     * How many further periods to buy, each at the price this item already bills at.
+     *
+     * Buying twelve monthly periods is not the same as buying one yearly term: a longer
+     * term is usually sold at a lower price, and that price is only reached by naming the
+     * interval. Use `interval_count` and `interval` for that.
+     * @minimum 1
+     */
+    periods?: number;
+    /**
+     * Renew for a term of this length instead, at the price currently sold for it. Give
+     * `interval` with it.
+     *
+     * Leaving both out renews at the price this item already bills at, which a later price
+     * change does not affect. Naming a term that differs from the current one is a fresh
+     * choice, so it is bought at today's price. Naming the current term changes nothing. A
+     * term sold at several prices that differ in termination policy is refused with 409
+     * `BILLING_RENEWAL_OPTION_AMBIGUOUS` unless `termination_policy` is given.
+     *
+     * List the terms on offer with the renewal prices operation.
+     * @minimum 1
+     */
+    interval_count?: number;
+    /** The unit interval_count counts in. */
+    interval?: RenewRequestInterval;
+    /** With `interval` and `interval_count`, chooses among prices of that term that differ in termination policy. */
+    termination_policy?: TerminationPolicy;
+    payment_method_id?: string;
+    /** Whether to pay from the balance, with or without `payment_method_id`. */
+    use_balance?: boolean;
+    /** Whether to pay from eligible credit grants before the balance. */
+    use_credits?: boolean;
+    return_url?: string;
+}
+/**
+ * As in renewing.
+ */
+export type RenewalOrderRequestInterval = (typeof RenewalOrderRequestInterval)[keyof typeof RenewalOrderRequestInterval];
+export declare const RenewalOrderRequestInterval: {
+    readonly day: "day";
+    readonly month: "month";
+    readonly year: "year";
+};
+/**
+ * The periods and price of the renewal, chosen as in renewing.
+ */
+export interface RenewalOrderRequest {
+    /** Purchase ID saved before submitting. Duplicate creation conflicts; query this order after an unknown result. */
+    order_id: string;
+    /**
+     * As in renewing.
+     * @minimum 1
+     */
+    periods?: number;
+    /**
+     * As in renewing.
+     * @minimum 1
+     */
+    interval_count?: number;
+    /** As in renewing. */
+    interval?: RenewalOrderRequestInterval;
+}
+export interface AutoRenewSet {
+    auto_renew: boolean;
+}
+/**
+ * pending_checkout has recorded purchase terms but no confirmed checkout; only a deferred order
+ * with an amount due reaches it, since a zero-total order completes checkout at placement.
+ * Confirmation moves it to pending. Both pending_checkout
+ * and pending can expire or be canceled; neither establishes service delivery.
+ *
+ * Follows the items. `pending` has confirmed checkout, is not yet accepted and may be paid or unpaid. `active` is
+ * accepted with items still being set up. `completed` means every item was set up.
+ * `partially_completed` means some items were set up and the others failed or were canceled and were
+ * refunded to their original payment sources. `failed` means no item was delivered and at least one failed; collected amounts for the
+ * undelivered items are refunded. `canceled` means every item was withdrawn without delivery; collected amounts are
+ * returned to their original payment sources.
+ */
+export type OrderStatus = (typeof OrderStatus)[keyof typeof OrderStatus];
+export declare const OrderStatus: {
+    readonly pending_checkout: "pending_checkout";
+    readonly pending: "pending";
+    readonly active: "active";
+    readonly completed: "completed";
+    readonly partially_completed: "partially_completed";
+    readonly failed: "failed";
+    readonly canceled: "canceled";
+};
+/**
+ * `pending` is waiting to be set up. `completed` was confirmed by the service.
+ * `failed` was not set up and its amount was refunded to the original payment sources.
+ * `canceled` was confirmed withdrawn without delivery; any collected amount is returned. A completed item is ended by canceling
+ * its subscription.
+ */
+export type OrderItemStatus = (typeof OrderItemStatus)[keyof typeof OrderItemStatus];
+export declare const OrderItemStatus: {
+    readonly pending: "pending";
+    readonly completed: "completed";
+    readonly failed: "failed";
+    readonly canceled: "canceled";
+};
+/**
+ * `adopt` brings a resource that already existed under billing. It charges nothing at
+ * the time and starts billing from the moment agreed.
+ */
+export type OrderType = (typeof OrderType)[keyof typeof OrderType];
+export declare const OrderType: {
+    readonly purchase: "purchase";
+    readonly renew: "renew";
+    readonly change: "change";
+    readonly adopt: "adopt";
+};
+/**
+ * When a plan change takes effect. `none` on anything that is not a change.
+ *
+ * `period_end` orders stay pending until the first period at the new price is paid. That period
+ * is invoiced shortly before the current paid period ends and starts when it ends; if the
+ * invoice is still unpaid by then, the order is canceled and the subscription renews or ends as
+ * usual. Renewing in the meantime moves all of this along with it.
+ */
+export type OrderChangeEffective = (typeof OrderChangeEffective)[keyof typeof OrderChangeEffective];
+export declare const OrderChangeEffective: {
+    readonly none: "none";
+    readonly immediate: "immediate";
+    readonly period_end: "period_end";
+};
+/**
+ * Purchase-related invoice amounts, without account contact details or payment methods. A draft
+ * order invoice shows base amounts awaiting checkout, not a confirmed discount or collectible total.
+ * Absent when no invoice has been created; absence does not establish acceptance or delivery.
+ */
+export interface InvoiceSummary {
+    id: string;
+    number?: string;
+    currency: string;
+    status: InvoiceStatus;
+    /**
+     * Sum of the line amounts before discounts. Where prices include tax, the tax contained in
+     * each line's discounted amount is taken out here, so that total = subtotal -
+     * discount_amount + tax_amount always holds.
+     */
+    subtotal: string;
+    /** Sum of the line discounts, taken off before tax. */
+    discount_amount: string;
+    tax_amount: string;
+    total: string;
+    amount_paid: string;
+    /**
+     * What is still collectible after applied credits and successful payments; never below zero.
+     * @pattern ^\d+(\.\d{1,10})?$
+     */
+    amount_due: string;
+    amount_refunded: string;
+    due_at?: string;
+}
+export type OrderItemInterval = (typeof OrderItemInterval)[keyof typeof OrderItemInterval];
+export declare const OrderItemInterval: {
+    readonly none: "none";
+    readonly day: "day";
+    readonly month: "month";
+    readonly year: "year";
+};
+/**
+ * The payment timing of the selected price.
+ */
+export type OrderItemBillingType = (typeof OrderItemBillingType)[keyof typeof OrderItemBillingType];
+export declare const OrderItemBillingType: {
+    readonly postpaid: "postpaid";
+    readonly prepaid: "prepaid";
+    readonly one_time: "one_time";
+};
+export type OrderItemConfiguration = {
+    [key: string]: unknown;
+};
+/**
+ * Frozen purchase terms. Monetary fields come from related invoice-line snapshots and are absent
+ * when there is no immediate invoice. Later catalog changes do not reprice this line. A new service
+ * purchase creates its pending subscription when this item is recorded, not when payment succeeds.
+ */
+export interface OrderItem {
+    /** @minimum 0 */
+    position?: number;
+    configuration?: OrderItemConfiguration;
+    /**
+     * Stable Billing subscription ID. A new prepaid or postpaid service purchase returns the
+     * pending subscription here; renewals and changes reference the existing subscription, which
+     * keeps its ID. Absent for delivery without a subscription. This is not a business resource ID.
+     */
+    subscription_id?: string;
+    interval: OrderItemInterval;
+    /** @minimum 1 */
+    interval_count?: number;
+    termination_policy?: TerminationPolicy;
+    refund_policy?: RefundPolicy;
+    /**
+     * Prepaid items only: the plan's one-month prepaid price for this item's quantity before tax, frozen
+     * at purchase, used to value time used under a prorated refund or a downgrade. Null when the plan has
+     * no prepaid period shorter than the one bought.
+     * @nullable
+     */
+    refund_monthly_amount?: string | null;
+    /**
+     * Prepaid items only: the plan's postpaid hourly price for this item's quantity before tax, frozen at
+     * purchase, used for time used short of a full month. Null when the plan has no postpaid price.
+     * @nullable
+     */
+    refund_hourly_amount?: string | null;
+    completes_on_payment: boolean;
+    recurring_amount?: string;
+    setup_amount?: string;
+    /** The payment timing of the selected price. */
+    billing_type: OrderItemBillingType;
+    /** Total tax after discounts, including any tax already included in the price. */
+    tax_amount?: string;
+    /** The part of tax_amount already included in gross_amount; it is not charged again. */
+    tax_included_amount?: string;
+    id: string;
+    order_id?: string;
+    price_id: string;
+    product_id?: ProductID;
+    product?: Product;
+    /** Which plan was bought. */
+    plan_id: string;
+    /**
+     * What it was called when bought. It does not follow later catalogue renames and is
+     * not translated.
+     */
+    plan_name: string;
+    quantity: string;
+    /**
+     * The unit amount of the price this line is charged under. Absent for a tiered price, which has no
+     * single unit amount, and for a change that takes effect at once, which is charged as `gross_amount`
+     * describes.
+     */
+    unit_amount?: Money;
+    /**
+     * Before discounts: the price applied to the quantity, which for a per-unit price is `unit_amount`
+     * times `quantity`; a minimum charge can make it higher. For an upgrade that takes effect at once it is
+     * the new price minus the old price for the time left in the paid period, both at the subscription's
+     * own period price, and the period end does not move; a downgrade charges nothing and may refund the
+     * difference instead. A change between equal period prices charges and refunds nothing. The setup fee is not part of it; see `setup_amount`.
+     *
+     * Under an inclusive tax rate it includes tax, as the price does, and the included part is
+     * `tax_included_amount`. A renewal at the agreed terms is the exception: the agreed amount excludes
+     * tax, and tax is added to it.
+     */
+    gross_amount?: Money;
+    /**
+     * The reduction on this line: from the coupon the order uses and, for a renewal at the agreed terms,
+     * from the discount the subscription carries.
+     *
+     * A carried discount is part of the agreed amount. It is listed here, and `gross_amount` is then
+     * `unit_amount` times `quantity`, except in two cases where `gross_amount` is the agreed amount and
+     * the carried discount is already reflected in it: the renewal order also uses a coupon the account
+     * holds, or the account's tax rate is inclusive.
+     */
+    discount_amount?: Money;
+    /** `gross_amount` less `discount_amount`. */
+    amount?: Money;
+    currency: string;
+    /** @nullable */
+    period_start?: string | null;
+    /** @nullable */
+    period_end?: string | null;
+    status: OrderItemStatus;
+}
+/**
+ * A recorded purchase. pending_checkout requires explicit Billing confirmation before collection
+ * or acceptance, even without an invoice. Coupon fields describe a discount confirmed at checkout and are absent
+ * before confirmation; a quote never populates them. A draft invoice contains base purchase
+ * amounts awaiting checkout. Payment and acceptance remain separate from resource delivery.
+ */
+export interface Order {
+    coupon_id?: string;
+    coupon?: ObjectIdentity;
+    promotion_code_id?: string;
+    /** Code text frozen when checkout applied the coupon. Absent for an account discount. */
+    promotion_code?: string;
+    invoice?: InvoiceSummary;
+    /** How the order was paid. Absent until it is paid. */
+    paid_with?: PaidWith;
+    account?: AccountIdentity;
+    cancel_reason?: string;
+    change_effective_at?: string;
+    id: string;
+    /**
+     * Which project it was bought for. Absent for a purchase made at account level, such
+     * as a membership.
+     * @nullable
+     */
+    project_id?: string | null;
+    /**
+     * The project and its current name, for display. Absent for a purchase at account level,
+     * and when the project no longer exists or its details cannot be read at the moment;
+     * `project_id` still identifies it then.
+     */
+    project?: NamedIdentity | null;
+    /**
+     * The billing account the order was placed with. It does not change when the project is later
+     * linked to another billing account. While this account is suspended or closed the order cannot
+     * be accepted, and a change scheduled for the end of a period is not invoiced and is called off
+     * when the current period ends; such requests fail with BILLING_ACCOUNT_UNAVAILABLE.
+     */
+    billing_account_id?: number;
+    currency: string;
+    /**
+     * `adopt` brings a resource that already existed under billing. It charges nothing at
+     * the time and starts billing from the moment agreed.
+     */
+    type: OrderType;
+    status: OrderStatus;
+    /**
+     * When a plan change takes effect. `none` on anything that is not a change.
+     *
+     * `period_end` orders stay pending until the first period at the new price is paid. That period
+     * is invoiced shortly before the current paid period ends and starts when it ends; if the
+     * invoice is still unpaid by then, the order is canceled and the subscription renews or ends as
+     * usual. Renewing in the meantime moves all of this along with it.
+     */
+    change_effective?: OrderChangeEffective;
+    /**
+     * Acceptance deadline. pending_checkout and pending orders can expire automatically.
+     * @nullable
+     */
+    expires_at?: string | null;
+    created_at: string;
+    /**
+     * What was bought. Present on a single order and on every order in a list, so a list
+     * can be rendered without a further request per row.
+     */
+    items: OrderItem[];
+}
+export interface OrderList {
+    items: Order[];
+    pagination: OffsetPagination;
+}
+export type DiscountStatus = (typeof DiscountStatus)[keyof typeof DiscountStatus];
+export declare const DiscountStatus: {
+    readonly active: "active";
+    readonly revoked: "revoked";
+};
+export type DiscountType = (typeof DiscountType)[keyof typeof DiscountType];
+export declare const DiscountType: {
+    readonly percentage: "percentage";
+    readonly fixed_amount: "fixed_amount";
+    readonly price_override: "price_override";
+    readonly free_setup: "free_setup";
+};
+/**
+ * A coupon held on this account. It applies at checkout without a code.
+ */
+export interface Discount {
+    min_amount?: string;
+    billing_account_id?: number;
+    coupon_id: string;
+    promotion_code_id?: string;
+    status: DiscountStatus;
+    revoked_at?: string;
+    type: DiscountType;
+    recurring?: boolean;
+    /** @minimum 1 */
+    recurring_cycles?: number;
+    id: string;
+    name?: string;
+    /** For a percentage discount, out of one hundred. */
+    percent_off?: string;
+    amount?: Money;
+    /** Caps a percentage discount. */
+    max_discount?: Money;
+    currency?: string;
+    /**
+     * What it may be used for. Absent means it applies to anything on the account,
+     * including setup fees and traffic.
+     */
+    applies_to: Applicability;
+    /** Restricted to your first purchase of anything it applies to. */
+    first_purchase_only?: boolean;
+    started_at?: string;
+    /** @nullable */
+    ended_at?: string | null;
+}
+export interface DiscountList {
+    items: Discount[];
+    pagination: OffsetPagination;
+}
+export interface OrderItemList {
+    items: OrderItem[];
+    pagination: OffsetPagination;
+}
+/**
+ * `included` came with a recurring purchase and ends with its subscription, `promotional` was
+ * granted.
+ */
+export type AllowanceSourceType = (typeof AllowanceSourceType)[keyof typeof AllowanceSourceType];
+export declare const AllowanceSourceType: {
+    readonly included: "included";
+    readonly promotional: "promotional";
+};
+export type AllowanceStatus = (typeof AllowanceStatus)[keyof typeof AllowanceStatus];
+export declare const AllowanceStatus: {
+    readonly active: "active";
+    readonly depleted: "depleted";
+    readonly expired: "expired";
+    readonly voided: "voided";
+};
+export interface Allowance {
+    /** Optional issuance key, unique within this billing account. */
+    idempotency_key?: string;
+    subscription_id?: string;
+    id: string;
+    billing_account_id?: number;
+    product: Product;
+    meter: ObjectIdentity;
+    /** The unit it is counted in, such as `MiB`. */
+    unit?: string;
+    /**
+     * `included` came with a recurring purchase and ends with its subscription, `promotional` was
+     * granted.
+     */
+    source_type: AllowanceSourceType;
+    name: string;
+    /** How much was granted. */
+    quantity: string;
+    /** How much is left. */
+    remaining_quantity: string;
+    /**
+     * Lower values are consumed first. At equal priority, earlier expiry and then earlier issuance take
+     * precedence.
+     */
+    priority?: number;
+    status: AllowanceStatus;
+    valid_from: string;
+    /**
+     * When it lapses. Anything unused at that point is lost; it is not refunded and does
+     * not carry over. Absent when it does not expire on its own.
+     * @nullable
+     */
+    valid_until?: string | null;
+}
+export interface AllowanceList {
+    items: Allowance[];
+    pagination: OffsetPagination;
+}
+export interface Entitlement {
+    product: Product;
+    feature: ObjectIdentity;
+    name?: string;
+    enabled: boolean;
+    /**
+     * When the subscription providing it ends. Absent for a metered subscription, which
+     * has no end date.
+     * @nullable
+     */
+    expires_at?: string | null;
+}
+export interface EntitlementList {
+    items: Entitlement[];
+    pagination: OffsetPagination;
+}
+export interface ProductList {
+    items: Product[];
+    pagination: OffsetPagination;
+}
+export interface PlanFeature {
+    feature: ObjectIdentity;
+    name: string;
+}
+export interface Plan {
+    /** False once archived. An archived plan cannot be bought until it is active again. */
+    active: boolean;
+    lookup_key?: string;
+    product: Product;
+    features: PlanFeature[];
+    id: string;
+    product_id: ProductID;
+    name: string;
+    description?: string;
+}
+export interface PlanList {
+    items: Plan[];
+    pagination: OffsetPagination;
+}
+/**
+ * `postpaid` charges for what is used, `prepaid` buys a period in advance, `one_time`
+ * charges once.
+ */
+export type PriceType = (typeof PriceType)[keyof typeof PriceType];
+export declare const PriceType: {
+    readonly postpaid: "postpaid";
+    readonly prepaid: "prepaid";
+    readonly one_time: "one_time";
+};
+/**
+ * How the amount is arrived at. `rated` means the rate depends on attributes such as
+ * region or machine type, and is looked up on a price list.
+ */
+export type PriceBillingScheme = (typeof PriceBillingScheme)[keyof typeof PriceBillingScheme];
+export declare const PriceBillingScheme: {
+    readonly per_unit: "per_unit";
+    readonly tiered: "tiered";
+    readonly rated: "rated";
+};
+/**
+ * `none` for a price that is not tiered, which is most of them.
+ *
+ * Otherwise `graduated` charges each band at its own rate, and `volume` charges
+ * everything at the rate of the band the total falls in.
+ */
+export type PriceTiersMode = (typeof PriceTiersMode)[keyof typeof PriceTiersMode];
+export declare const PriceTiersMode: {
+    readonly none: "none";
+    readonly graduated: "graduated";
+    readonly volume: "volume";
+};
+export type PriceInterval = (typeof PriceInterval)[keyof typeof PriceInterval];
+export declare const PriceInterval: {
+    readonly none: "none";
+    readonly day: "day";
+    readonly month: "month";
+    readonly year: "year";
+};
+export interface Tier {
+    /**
+     * The upper bound of this band. Null on the last band, which has no bound.
+     * @nullable
+     */
+    up_to?: string | null;
+    unit_amount: Money;
+    /** Charged once when this band is reached, in addition to the per-unit amount. */
+    flat_amount?: Money;
+}
+export interface Price {
+    rate_card?: ObjectIdentity;
+    lookup_key?: string;
+    product: Product;
+    plan: ObjectIdentity;
+    meter_id?: string;
+    meter?: ObjectIdentity;
+    unit_quantity: string;
+    /** False once archived. An archived price cannot be bought until it is active again. */
+    active: boolean;
+    termination_policy?: TerminationPolicy;
+    refund_policy?: RefundPolicy;
+    product_id?: ProductID;
+    id: string;
+    plan_id: string;
+    currency: string;
+    /**
+     * `postpaid` charges for what is used, `prepaid` buys a period in advance, `one_time`
+     * charges once.
+     */
+    type: PriceType;
+    /**
+     * How the amount is arrived at. `rated` means the rate depends on attributes such as
+     * region or machine type, and is looked up on a price list.
+     */
+    billing_scheme: PriceBillingScheme;
+    /** Present for `per_unit`. */
+    unit_amount?: Money;
+    /**
+     * `none` for a price that is not tiered, which is most of them.
+     *
+     * Otherwise `graduated` charges each band at its own rate, and `volume` charges
+     * everything at the rate of the band the total falls in.
+     */
+    tiers_mode?: PriceTiersMode;
+    /** Present for `tiered`, in ascending order. */
+    tiers?: Tier[];
+    /** For `rated` prices, the price list the rates are read from. */
+    rate_card_id?: string;
+    /** The smallest quantity that can be bought. Absent means no lower bound. */
+    min_quantity?: string;
+    /**
+     * The largest purchasable quantity. Omitted when no maximum applies. A quantity above this limit is
+     * rejected with BILLING_PRICE_INVALID and field=max_quantity.
+     */
+    max_quantity?: string;
+    /** Quantities must be a multiple of this. Absent means any quantity within the bounds. */
+    quantity_step?: string;
+    /** For prepaid prices, how many periods one purchase covers. */
+    interval_count?: number;
+    interval: PriceInterval;
+    setup_fee?: Money;
+}
+export interface PriceList {
+    items: Price[];
+    pagination: OffsetPagination;
+}
+/**
+ * The attributes this rate applies to, such as region and machine type.
+ */
+export type RateDimensions = {
+    [key: string]: string;
+};
+export type RatePricingModel = (typeof RatePricingModel)[keyof typeof RatePricingModel];
+export declare const RatePricingModel: {
+    readonly per_unit: "per_unit";
+    readonly graduated: "graduated";
+    readonly volume: "volume";
+};
+export interface Rate {
+    meter: ObjectIdentity;
+    /** The unit readings arrive in, such as `core-second`. */
+    unit?: string;
+    /** The attributes this rate applies to, such as region and machine type. */
+    dimensions: RateDimensions;
+    pricing_model: RatePricingModel;
+    /** Present for `per_unit`. Tiered rates carry their amounts on the tiers. */
+    unit_amount?: Money;
+    /** Present for `graduated` and `volume`, in ascending order. */
+    tiers?: Tier[];
+    /**
+     * How many measured units one amount covers. An hourly rate on a per-second meter is
+     * `"3600"`.
+     */
+    unit_quantity?: string;
+    currency: string;
+    effective_from: string;
+    /** @nullable */
+    effective_to?: string | null;
+}
+export interface RateList {
+    items: Rate[];
+    pagination: OffsetPagination;
+}
+/**
+ * Narrows the selection when a plan offers more than one billing type.
+ */
+export type QuoteItemInputPriceType = (typeof QuoteItemInputPriceType)[keyof typeof QuoteItemInputPriceType];
+export declare const QuoteItemInputPriceType: {
+    readonly postpaid: "postpaid";
+    readonly prepaid: "prepaid";
+    readonly one_time: "one_time";
+};
+export type QuoteItemInputInterval = (typeof QuoteItemInputInterval)[keyof typeof QuoteItemInputInterval];
+export declare const QuoteItemInputInterval: {
+    readonly none: "none";
+    readonly day: "day";
+    readonly month: "month";
+    readonly year: "year";
+};
+/**
+ * The attributes the price depends on — region, instance type, token class.
+ *
+ * Required when the price draws its rates from a price list, which is how anything
+ * sold by region or by machine type is priced. A price that carries a single unit
+ * amount, or a ladder, has no attributes to give and takes none.
+ *
+ * Every attribute the meter declares must be present. A combination with no rate
+ * covering it is refused rather than priced at zero.
+ */
+export type QuoteItemInputDimensions = {
+    [key: string]: string;
+};
+/**
+ * Identify a price directly, or select a price for a plan. For each resource give its ID or lookup
+ * key, never both. Lookup keys require product_id. Meter, dimensions or duration_seconds request a
+ * postpaid usage estimate. Such an estimate cannot be combined with a promotion code or treated as a
+ * checkout amount. Without a usage estimate, a postpaid item includes only any setup charge.
+ */
+export interface QuoteItemInput {
+    /**
+     * @minLength 1
+     * @maxLength 128
+     */
+    price_lookup_key?: string;
+    /**
+     * @minLength 1
+     * @maxLength 128
+     */
+    plan_lookup_key?: string;
+    price_id?: string;
+    product_id?: ProductID;
+    plan_id?: string;
+    /** Narrows the selection when a plan offers more than one billing type. */
+    price_type?: QuoteItemInputPriceType;
+    interval?: QuoteItemInputInterval;
+    /** @minimum 1 */
+    interval_count?: number;
+    /** Selects among prepaid prices with otherwise identical billing terms. Ambiguous terms are refused instead of choosing a price arbitrarily. */
+    termination_policy?: TerminationPolicy;
+    /** @pattern ^(?:(?:[1-9][0-9]{0,27}|0(?:[1-9][0-9]{0,26}|0(?:[1-9][0-9]{0,25}|0(?:[1-9][0-9]{0,24}|0(?:[1-9][0-9]{0,23}|0(?:[1-9][0-9]{0,22}|0(?:[1-9][0-9]{0,21}|0(?:[1-9][0-9]{0,20}|0(?:[1-9][0-9]{0,19}|0(?:[1-9][0-9]{0,18}|0(?:[1-9][0-9]{0,17}|0(?:[1-9][0-9]{0,16}|0(?:[1-9][0-9]{0,15}|0(?:[1-9][0-9]{0,14}|0(?:[1-9][0-9]{0,13}|0(?:[1-9][0-9]{0,12}|0(?:[1-9][0-9]{0,11}|0(?:[1-9][0-9]{0,10}|0(?:[1-9][0-9]{0,9}|0(?:[1-9][0-9]{0,8}|0(?:[1-9][0-9]{0,7}|0(?:[1-9][0-9]{0,6}|0(?:[1-9][0-9]{0,5}|0(?:[1-9][0-9]{0,4}|0(?:[1-9][0-9]{0,3}|0(?:[1-9][0-9]{0,2}|0(?:[1-9][0-9]{0,1}|0[1-9])))))))))))))))))))))))))))([.][0-9]{1,10})?|0{1,28}[.](?:[1-9][0-9]{0,9}|0(?:[1-9][0-9]{0,8}|0(?:[1-9][0-9]{0,7}|0(?:[1-9][0-9]{0,6}|0(?:[1-9][0-9]{0,5}|0(?:[1-9][0-9]{0,4}|0(?:[1-9][0-9]{0,3}|0(?:[1-9][0-9]{0,2}|0(?:[1-9][0-9]{0,1}|0[1-9]))))))))))$ */
+    quantity: string;
+    meter_id?: string;
+    /**
+     * @minLength 1
+     * @maxLength 128
+     */
+    meter_lookup_key?: string;
+    /**
+     * The attributes the price depends on — region, instance type, token class.
+     *
+     * Required when the price draws its rates from a price list, which is how anything
+     * sold by region or by machine type is priced. A price that carries a single unit
+     * amount, or a ladder, has no attributes to give and takes none.
+     *
+     * Every attribute the meter declares must be present. A combination with no rate
+     * covering it is refused rather than priced at zero.
+     */
+    dimensions?: QuoteItemInputDimensions;
+    /**
+     * For metered items, how long to price for. This allows an estimate such as "about
+     * this much per month" to be shown before anything exists. The priced quantity is
+     * `quantity` multiplied by this duration.
+     */
+    duration_seconds?: number;
+}
+export interface SpendRow {
+    product?: Product;
+    plan_id?: string;
+    plan_name?: string;
+    /** Present only when grouped by resource. */
+    resource_id?: string;
+    amount: Money;
+    currency: string;
+}
+export interface SpendRowList {
+    items: SpendRow[];
+    /** The sum over the whole period, not only the page returned. */
+    total: Money;
+    currency: string;
+    pagination: OffsetPagination;
+}
+export type ActiveResourceDimensions = {
+    [key: string]: string;
+};
+export type ActiveResourceStatus = (typeof ActiveResourceStatus)[keyof typeof ActiveResourceStatus];
+export declare const ActiveResourceStatus: {
+    readonly active: "active";
+    readonly suspended: "suspended";
+    readonly closing: "closing";
+    readonly completed: "completed";
+};
+/**
+ * A resource currently accruing charges by the second.
+ */
+export interface ActiveResource {
+    id: string;
+    ended_at?: string;
+    suspended_at?: string;
+    state_changed_at?: string;
+    /** The postpaid subscription charged for this metering record, including shared services. */
+    subscription_id: string;
+    resource_id: string;
+    product: Product;
+    /** What it is, as its own service names it. */
+    resource_type?: string;
+    meter: ObjectIdentity;
+    unit?: string;
+    /** How much is held — cores, MiB, cards. Not how much has been used. */
+    quantity: string;
+    dimensions?: ActiveResourceDimensions;
+    status: ActiveResourceStatus;
+    started_at: string;
+    /** Usage has been generated up to this boundary; it does not imply invoicing or payment. */
+    metered_until: string;
+    project_id?: string;
+}
+export interface ActiveResourceList {
+    items: ActiveResource[];
+    pagination: OffsetPagination;
+}
+/**
+ * An estimate of the refundable value of one order or selected items. This does not cancel the order, stop service or create a refund.
+ */
+export interface OrderRefundQuoteInput {
+    order_id: string;
+    /**
+     * Estimate only these items. Omit to estimate the whole order. Every item must belong to the order.
+     * @minItems 1
+     * @maxItems 100
+     */
+    order_item_ids?: string[];
+}
+/**
+ * "Quote exactly one target: proposed items, an existing order, renewals, a cancellation or an order
+ * refund. All targets use the specified billing account. Nothing is saved, charged, reserved or
+ * canceled. Promotion codes apply only to a purchase basket or an existing order. An invalid
+ * combination returns BILLING_PURCHASE_INVALID with the offending field."
+ */
+export interface QuoteRequest {
+    /**
+     * The billing account to price for. It must belong to you. Existing orders must have been purchased
+     * with this account; renewals and cancellations must currently be paid for by it.
+     * @minimum 1
+     */
+    billing_account_id: number;
+    /**
+     * A proposed purchase priced in the account currency. Metered items may estimate specified usage
+     * quantities; those estimates are not amounts collectible at checkout.
+     * @minItems 1
+     * @maxItems 100
+     */
+    items?: QuoteItemInput[];
+    /**
+     * Preview checkout of this existing order. Its recorded purchase terms supply every line, and a
+     * confirmed order returns its recorded amounts. A preview does not change the order.
+     */
+    order_id?: string;
+    /**
+     * Preview renewing these subscriptions, each at most once. Each entry represents a separate
+     * renewal order. To preview a new promotion code, create a renewal order and quote it by order_id.
+     * @minItems 1
+     * @maxItems 100
+     */
+    renewals?: QuoteRenewal[];
+    cancellation?: QuoteCancellation;
+    /**
+     * @minLength 1
+     * @maxLength 64
+     */
+    promotion_code?: string;
+    refund?: OrderRefundQuoteInput;
+}
+/**
+ * Pagination metadata for keyset traversal. Pass next_cursor as cursor to read the following page; null means there is no following page.
+ */
+export interface CursorPagination {
+    /** @minimum 1 */
+    page_size: number;
+    /** @nullable */
+    next_cursor?: string | null;
+}
+/**
+ * Error
+ */
+export type ErrorResponse = Error;
+/**
+ * Unchanged since the `ETag` that was sent. No body.
+ */
+export type NotModifiedResponse = void;
+export type FromParameter = string;
+/**
+ * Exclusive.
+ */
+export type ToParameter = string;
+/**
+ * Restrict to one of your accounts. All of them when omitted.
+ */
+export type AccountIdQueryParameter = number;
+/**
+ * The `ETag` from an earlier reply. When the catalogue has not changed since, the
+ * answer is `304` with no body.
+ *
+ * Send it on every catalogue read. An unchanged catalogue is answered without a body.
+ */
+export type IfNoneMatchParameter = string;
+export type FromRequiredParameter = string;
+/**
+ * Exclusive. One month is `[2026-09-01, 2026-10-01)`.
+ */
+export type ToRequiredParameter = string;
+/**
+ * Restrict the account-authorized results to these projects. Omit for all projects and account-level records. This filter does not grant access to another billing account.
+ */
+export type ProjectIdsQueryParameter = string[];
+export type ListCurrenciesParams = {
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+};
+export type ListBillingAccountsParams = {
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+};
+export type ListPaymentOptionsParams = {
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+};
+export type ListProjectAssignmentsParams = {
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+    billing_account_id?: number;
+    /**
+     * Restrict the account-authorized results to these projects. Omit for all projects and account-level records. This filter does not grant access to another billing account.
+     * @minItems 1
+     * @maxItems 100
+     */
+    project_ids?: ProjectIdsQueryParameter;
+};
+export type ListTopUpsParams = {
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+    /**
+     * Restrict to one of your accounts. All of them when omitted.
+     */
+    billing_account_id?: AccountIdQueryParameter;
+};
+export type ListPaymentMethodsParams = {
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+    /**
+     * Restrict to one of your accounts. All of them when omitted.
+     */
+    billing_account_id?: AccountIdQueryParameter;
+};
+export type PreviewInvoicePaymentParams = {
+    /**
+     * As in paying. True when omitted.
+     */
+    use_balance?: boolean;
+    /**
+     * As in paying. True when omitted.
+     */
+    use_credits?: boolean;
+};
+export type ListInvoicesParams = {
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+    /**
+     * Restrict to one of your accounts. All of them when omitted.
+     */
+    billing_account_id?: AccountIdQueryParameter;
+    status?: InvoiceStatus;
+    from?: FromParameter;
+    /**
+     * Exclusive.
+     */
+    to?: ToParameter;
+};
+export type ListInvoiceItemsParams = {
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+};
+export type ListTransactionsParams = {
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+    /**
+     * Restrict to one of your accounts. All of them when omitted.
+     */
+    billing_account_id?: AccountIdQueryParameter;
+    from?: FromParameter;
+    /**
+     * Exclusive.
+     */
+    to?: ToParameter;
+};
+export type ListAccountDiscountsParams = {
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+    /**
+     * Restrict to one of your accounts. All of them when omitted.
+     */
+    billing_account_id?: AccountIdQueryParameter;
+};
+export type ListCreditGrantsParams = {
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+    /**
+     * Restrict to one of your accounts. All of them when omitted.
+     */
+    billing_account_id?: AccountIdQueryParameter;
+    status?: ListCreditGrantsStatus;
+};
+export type ListCreditGrantsStatus = (typeof ListCreditGrantsStatus)[keyof typeof ListCreditGrantsStatus];
+export declare const ListCreditGrantsStatus: {
+    readonly active: "active";
+    readonly depleted: "depleted";
+    readonly expired: "expired";
+    readonly voided: "voided";
+};
+export type ListRefundsParams = {
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+    /**
+     * Restrict to one of your accounts. All of them when omitted.
+     */
+    billing_account_id?: AccountIdQueryParameter;
+    /**
+     * Only the refunds of this invoice.
+     */
+    invoice_id?: string;
+    /**
+     * Only the refunds that belong to this order: those of its invoice, such as the refund of a
+     * purchase that could not be delivered, and those it caused on an earlier invoice, such as
+     * the difference returned after a downgrade.
+     */
+    order_id?: string;
+};
+export type ListUsageChargesParams = {
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+    /**
+     * Restrict to one of your accounts. All of them when omitted.
+     */
+    billing_account_id?: AccountIdQueryParameter;
+    product_id?: ProductID;
+    resource_id?: string;
+    /**
+     * Only the charges summed into this usage invoice line.
+     */
+    invoice_item_id?: string;
+    from?: FromParameter;
+    /**
+     * Exclusive.
+     */
+    to?: ToParameter;
+    /**
+     * Restrict the account-authorized results to these projects. Omit for all projects and account-level records. This filter does not grant access to another billing account.
+     * @minItems 1
+     * @maxItems 100
+     */
+    project_ids?: ProjectIdsQueryParameter;
+    meter_id?: string;
+};
+export type ListSubscriptionsParams = {
+    expiring_before?: string;
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+    /**
+     * Restrict to one of your accounts. All of them when omitted.
+     */
+    billing_account_id?: AccountIdQueryParameter;
+    /**
+     * Restrict the account-authorized results to these projects. Omit for all projects and account-level records. This filter does not grant access to another billing account.
+     * @minItems 1
+     * @maxItems 100
+     */
+    project_ids?: ProjectIdsQueryParameter;
+};
+export type ListCancellationsParams = {
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+    /**
+     * Restrict to one of your accounts. All of them when omitted.
+     */
+    billing_account_id?: AccountIdQueryParameter;
+    /**
+     * Only cancellations that include this subscription.
+     */
+    subscription_id?: string;
+    /**
+     * Only cancellations in this status. `open` means requested, scheduled or releasing.
+     */
+    status?: ListCancellationsStatus;
+    /**
+     * Restrict the account-authorized results to these projects. Omit for all projects and account-level records. This filter does not grant access to another billing account.
+     * @minItems 1
+     * @maxItems 100
+     */
+    project_ids?: ProjectIdsQueryParameter;
+};
+export type ListCancellationsStatus = (typeof ListCancellationsStatus)[keyof typeof ListCancellationsStatus];
+export declare const ListCancellationsStatus: {
+    readonly open: "open";
+    readonly requested: "requested";
+    readonly scheduled: "scheduled";
+    readonly releasing: "releasing";
+    readonly completed: "completed";
+    readonly canceled: "canceled";
+    readonly failed: "failed";
+};
+export type ListRenewalPricesParams = {
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+};
+export type ListAllowancesParams = {
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+    /**
+     * Restrict to one of your accounts. All of them when omitted.
+     */
+    billing_account_id?: AccountIdQueryParameter;
+    /**
+     * Filter by the meter UUID.
+     */
+    meter_id?: string;
+    status?: ListAllowancesStatus;
+    product_id?: ProductID;
+    /**
+     * Restrict the account-authorized results to these projects. Omit for all projects and account-level records. This filter does not grant access to another billing account.
+     * @minItems 1
+     * @maxItems 100
+     */
+    project_ids?: ProjectIdsQueryParameter;
+};
+export type ListAllowancesStatus = (typeof ListAllowancesStatus)[keyof typeof ListAllowancesStatus];
+export declare const ListAllowancesStatus: {
+    readonly active: "active";
+    readonly depleted: "depleted";
+    readonly expired: "expired";
+    readonly voided: "voided";
+};
+export type ListOrdersParams = {
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+    /**
+     * Restrict to one of your accounts. All of them when omitted.
+     */
+    billing_account_id?: AccountIdQueryParameter;
+    status?: OrderStatus;
+    from?: FromParameter;
+    /**
+     * Exclusive.
+     */
+    to?: ToParameter;
+    /**
+     * Restrict the account-authorized results to these projects. Omit for all projects and account-level records. This filter does not grant access to another billing account.
+     * @minItems 1
+     * @maxItems 100
+     */
+    project_ids?: ProjectIdsQueryParameter;
+};
+export type ListOrderItemsParams = {
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+};
+export type ListEntitlementsParams = {
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+    /**
+     * Restrict to one of your accounts. All of them when omitted.
+     */
+    billing_account_id?: AccountIdQueryParameter;
+    /**
+     * Restrict the account-authorized results to these projects. Omit for all projects and account-level records. This filter does not grant access to another billing account.
+     * @minItems 1
+     * @maxItems 100
+     */
+    project_ids?: ProjectIdsQueryParameter;
+    product_id?: ProductID;
+};
+export type ListPricesParams = {
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+    /**
+     * ISO 4217, three uppercase letters.
+     * @minLength 3
+     * @maxLength 3
+     */
+    currency: string;
+    product_id?: ProductID;
+    /**
+     * Narrows to one payment timing.
+     */
+    type?: ListPricesType;
+};
+export type ListPricesType = (typeof ListPricesType)[keyof typeof ListPricesType];
+export declare const ListPricesType: {
+    readonly postpaid: "postpaid";
+    readonly prepaid: "prepaid";
+    readonly one_time: "one_time";
+};
+export type ListPricesHeaders = {
+    /**
+     * The `ETag` from an earlier reply. When the catalogue has not changed since, the
+     * answer is `304` with no body.
+     *
+     * Send it on every catalogue read. An unchanged catalogue is answered without a body.
+     */
+    "If-None-Match"?: IfNoneMatchParameter;
+};
+export type ListProductsParams = {
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+};
+export type ListProductsHeaders = {
+    /**
+     * The `ETag` from an earlier reply. When the catalogue has not changed since, the
+     * answer is `304` with no body.
+     *
+     * Send it on every catalogue read. An unchanged catalogue is answered without a body.
+     */
+    "If-None-Match"?: IfNoneMatchParameter;
+};
+export type GetProductHeaders = {
+    /**
+     * The `ETag` from an earlier reply. When the catalogue has not changed since, the
+     * answer is `304` with no body.
+     *
+     * Send it on every catalogue read. An unchanged catalogue is answered without a body.
+     */
+    "If-None-Match"?: IfNoneMatchParameter;
+};
+export type GetPlanHeaders = {
+    /**
+     * The `ETag` from an earlier reply. When the catalogue has not changed since, the
+     * answer is `304` with no body.
+     *
+     * Send it on every catalogue read. An unchanged catalogue is answered without a body.
+     */
+    "If-None-Match"?: IfNoneMatchParameter;
+};
+export type GetPriceHeaders = {
+    /**
+     * The `ETag` from an earlier reply. When the catalogue has not changed since, the
+     * answer is `304` with no body.
+     *
+     * Send it on every catalogue read. An unchanged catalogue is answered without a body.
+     */
+    "If-None-Match"?: IfNoneMatchParameter;
+};
+export type ListPlansParams = {
+    product_id: ProductID;
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+};
+export type ListPlansHeaders = {
+    /**
+     * The `ETag` from an earlier reply. When the catalogue has not changed since, the
+     * answer is `304` with no body.
+     *
+     * Send it on every catalogue read. An unchanged catalogue is answered without a body.
+     */
+    "If-None-Match"?: IfNoneMatchParameter;
+};
+export type ListPricesByPlanParams = {
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+    currency?: string;
+};
+export type ListPricesByPlanHeaders = {
+    /**
+     * The `ETag` from an earlier reply. When the catalogue has not changed since, the
+     * answer is `304` with no body.
+     *
+     * Send it on every catalogue read. An unchanged catalogue is answered without a body.
+     */
+    "If-None-Match"?: IfNoneMatchParameter;
+};
+export type ListRatesParams = {
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+    /**
+     * Filter by the meter UUID.
+     */
+    meter_id?: string;
+    /**
+     * Return the rates in effect at this moment. Defaults to now.
+     */
+    at?: string;
+};
+export type ListRatesHeaders = {
+    /**
+     * The `ETag` from an earlier reply. When the catalogue has not changed since, the
+     * answer is `304` with no body.
+     *
+     * Send it on every catalogue read. An unchanged catalogue is answered without a body.
+     */
+    "If-None-Match"?: IfNoneMatchParameter;
+};
+export type ListActiveResourcesParams = {
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+    resource_id?: string;
+    /**
+     * Restrict to one of your accounts. All of them when omitted.
+     */
+    billing_account_id?: AccountIdQueryParameter;
+    /**
+     * Restrict the account-authorized results to these projects. Omit for all projects and account-level records. This filter does not grant access to another billing account.
+     * @minItems 1
+     * @maxItems 100
+     */
+    project_ids?: ProjectIdsQueryParameter;
+    meter_id?: string;
+    product_id?: ProductID;
+    status?: ListActiveResourcesStatus;
+};
+export type ListActiveResourcesStatus = (typeof ListActiveResourcesStatus)[keyof typeof ListActiveResourcesStatus];
+export declare const ListActiveResourcesStatus: {
+    readonly active: "active";
+    readonly suspended: "suspended";
+    readonly closing: "closing";
+    readonly completed: "completed";
+};
+export type ListSpendParams = {
+    from: FromRequiredParameter;
+    /**
+     * Exclusive. One month is `[2026-09-01, 2026-10-01)`.
+     */
+    to: ToRequiredParameter;
+    /**
+     * `resource` groups by the resource each charge names. Items billed under their own
+     * identifier — a disk, a public address — appear as their own rows rather than under
+     * the machine they are attached to, since the relationship between them is known to
+     * the owning service and not here.
+     */
+    group_by?: ListSpendGroupBy;
+    /**
+     * Filter by the fixed platform service ID.
+     */
+    product_id?: ProductID;
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+    /**
+     * The authorized billing account whose currency and charges are used for this report.
+     */
+    billing_account_id: number;
+    /**
+     * Restrict the account-authorized results to these projects. Omit for all projects and account-level records. This filter does not grant access to another billing account.
+     * @minItems 1
+     * @maxItems 100
+     */
+    project_ids?: ProjectIdsQueryParameter;
+};
+export type ListSpendGroupBy = (typeof ListSpendGroupBy)[keyof typeof ListSpendGroupBy];
+export declare const ListSpendGroupBy: {
+    readonly product: "product";
+    readonly plan: "plan";
+    readonly resource: "resource";
+};