@leaflow/sdk 0.0.0-dev.53.gd8db059 → 0.0.0-dev.538.g0285c19

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

@@ -0,0 +1,4673 @@
+/**
+ * Generated by orval 🍺
+ * Do not edit manually.
+ * Leaflow Billing API
+ * Products, prices, orders, subscriptions and account billing. Operations on a billing account require an account access token. The account, its balance, payment options and checkout previews are also readable by members of the projects it currently pays for; changing the account and moving its funds need the owner. Members of a project, as each operation states, can also read the project's billing account, subscriptions and orders, complete and pay for its purchases, preview the checkout of purchases, changes and renewals, preview cancellations, and, with the project permission `billing:finance.manage` granted in IAM, renew, cancel and turn automatic renewal of its subscriptions on or off, change its billing account and read its costs. A member without the permission an operation needs is refused with 403 `PERMISSION_DENIED` and `meta.permission`; a caller who is not a member, with 403 `IAM_NOT_PROJECT_MEMBER`. Public catalogue operations declare no security requirement.
+ * OpenAPI spec version: v1
+ */
+/**
+ * Whether a cancellation of a delivered purchase may take effect immediately or only at the end of its paid term; refunds follow the refund policy. When absent, no cancellation terms were agreed.
+ */
+export type CancellationPolicy = (typeof CancellationPolicy)[keyof typeof CancellationPolicy];
+export declare const CancellationPolicy: {
+    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
+ * or above what remains unrefunded. Time used runs from the period start to the effective cancellation, by the
+ * second. Each whole month from the period start is valued at the order item's `monthly_list_amount`, and the
+ * remainder at that amount in proportion to the length of the month it falls in; without `monthly_list_amount`,
+ * time used is valued at the amount paid in proportion to the length of the period. A renewal starts a new
+ * period, and an immediate change starts one at the change. Discounts and setup fees are not refunded. Refunds
+ * return to the original payment sources, with tax refunded in proportion.
+ *
+ * `short_rate` refunds as `prorated`, except that when the cancellation takes effect less than
+ * `short_rate_threshold_seconds` after the period start, the value of the time used is multiplied by
+ * `short_rate_multiplier`, up to `monthly_list_amount` for each month begun or, without `monthly_list_amount`,
+ * up to the amount paid.
+ */
+export type RefundPolicy = (typeof RefundPolicy)[keyof typeof RefundPolicy];
+export declare const RefundPolicy: {
+    readonly none: "none";
+    readonly prorated: "prorated";
+    readonly short_rate: "short_rate";
+};
+export interface OrderCancel {
+    /**
+     * Omit to select all still-pending items. Explicit selections name one or more items of this order; successful items cannot be reversed here.
+     * @minItems 1
+     * @maxItems 100
+     */
+    order_item_ids?: string[];
+}
+/**
+ * One subscription item to end, each at most once.
+ */
+export interface CancellationItemInput {
+    subscription_item_id: string;
+}
+/**
+ * When subscriptions end. immediate ends them now and refunds the unused value under their refund terms; period_end
+ * ends them at the end of their paid period. The cancellation terms fixed when a subscription was bought decide which
+ * modes it allows: a pay-as-you-go subscription ends only immediately, and a prepaid one whose terms allow only the
+ * end of its paid period ends only then. Billing refuses a mode the terms do not allow with HTTP 422
+ * BILLING_CANCELLATION_MODE_FIXED.
+ */
+export type CancellationMode = (typeof CancellationMode)[keyof typeof CancellationMode];
+export declare const CancellationMode: {
+    readonly immediate: "immediate";
+    readonly period_end: "period_end";
+};
+/**
+ * What ending these items together would return, for one mode; preview `immediate` and `period_end` separately to compare. Refused with 409 `BILLING_SUBSCRIPTION_OPERATION_PENDING` when an item is already being canceled (`meta.cancellation_id`), its subscription is being reclaimed (`meta.reason` `reclaim_requested`) or the item has a paid change waiting to switch (`meta.order_id`).
+ */
+export interface CancellationPreviewRequest {
+    /**
+     * A billing account you own that currently pays for every item.
+     * @minimum 1
+     */
+    billing_account_id: number;
+    /**
+     * The items to end together, all of one service, including every item released with a resource.
+     * @minItems 1
+     * @maxItems 50
+     */
+    items: CancellationItemInput[];
+    mode: CancellationMode;
+}
+/**
+ * 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;
+/**
+ * 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;
+}
+/**
+ * `one_time` charges once when bought. `recurring` charges again for every period, or for usage as it is settled.
+ */
+export type PriceType = (typeof PriceType)[keyof typeof PriceType];
+export declare const PriceType: {
+    readonly one_time: "one_time";
+    readonly recurring: "recurring";
+};
+/**
+ * `licensed` charges for the quantity bought, each period paid before it starts. `metered` charges for the usage
+ * reported, after it is settled; a metered subscription lasts until it is canceled. A one-time price is licensed.
+ */
+export type UsageType = (typeof UsageType)[keyof typeof UsageType];
+export declare const UsageType: {
+    readonly licensed: "licensed";
+    readonly metered: "metered";
+};
+/**
+ * One subscription item of the previewed cancellation.
+ */
+export interface CancellationPreviewItem {
+    subscription_item_id: string;
+    /** The subscription the item belongs to. */
+    subscription_id: string;
+    plan_id: string;
+    plan_name: string;
+    /** The project and its current name. Absent for an account-level purchase or when the project cannot be read. */
+    project?: NamedIdentity | null;
+    type: PriceType;
+    usage_type: UsageType;
+    /** Whether the item's subscription renews automatically now. Creating a cancellation of every continuing item of the subscription turns it off; withdrawing it turns it back on for a subscription with only metered items but not for one with licensed items. */
+    auto_renew: boolean;
+    unused_amount: Money;
+    short_rate_surcharge_amount: Money;
+    refundable_amount: Money;
+    refund_amount: Money;
+    credit_amount: Money;
+    tax_amount: Money;
+    forfeited_amount: Money;
+}
+/**
+ * What the cancellation would return, per item 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 in proportion to the time remaining.
+ * - `short_rate_surcharge_amount`: before tax, the part of `forfeited_amount` due to the short rate of the
+ *   refund policy.
+ * - `refundable_amount`: what is returned the way it was paid, tax included; `refund_amount` plus
+ *   `credit_amount`.
+ * - `refund_amount`: the part returned to the balance or 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.
+ *
+ * Metered and one-time items show zero; their usage until release is charged as usual.
+ */
+export interface CancellationPreview {
+    mode: CancellationMode;
+    /** For `period_end`, when release begins, the end of the subscriptions' current 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;
+    short_rate_surcharge_amount: Money;
+    refundable_amount: Money;
+    refund_amount: Money;
+    credit_amount: Money;
+    tax_amount: Money;
+    forfeited_amount: Money;
+    items: CancellationPreviewItem[];
+}
+export interface CancellationCreate {
+    /**
+     * As in the preview.
+     * @minItems 1
+     * @maxItems 50
+     */
+    items: CancellationItemInput[];
+    mode: CancellationMode;
+    /** For `immediate`, the preview's `proration_date`: 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 preview's `refundable_amount`; the cancellation is refused when the refund differs. */
+    expected_refundable_amount: Money & string;
+    /**
+     * A note from the account holder, kept with the cancellation.
+     * @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 requested 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";
+};
+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 item of the cancellation.
+ */
+export interface CancellationItem {
+    /** The item's entry in the cancellation, the same as `SubscriptionItem.cancellation.id`. */
+    id: string;
+    subscription_item_id: string;
+    /** The subscription the item belongs to. */
+    subscription_id: string;
+    plan_id: string;
+    plan_name: string;
+    type: PriceType;
+    /**
+     * When the cancellation covers every continuing item of a subscription, creating it turned the
+     * subscription's automatic renewal off; withdrawing it turns renewal back on for a subscription with
+     * only `metered` items and leaves it off for one with `licensed` items.
+     */
+    usage_type: UsageType;
+    status: CancellationItemStatus;
+    /** The release stopped or its result is unknown; present while the release needs resolution. */
+    failure_code?: string;
+    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 subscription items 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 item has ended and its refund has been made.
+ * - `canceled`: withdrawn before release began; the items continue.
+ * - `failed`: the service could not carry it out, for the reason in `failure_code`; the
+ *   items continue and can be canceled again.
+ */
+export interface Cancellation {
+    id: string;
+    status: CancellationStatus;
+    mode: CancellationMode;
+    scheduled_at?: string;
+    /** For `immediate`, the second the refund is computed as of. */
+    proration_date?: string;
+    /** Who requested it; `project_deletion` means the project was deleted. */
+    origin: CancellationOrigin;
+    /** The billing account paying for these items when the cancellation was created: the purchasing account of an account-level purchase, or the project's linked account. */
+    billing_account_id: number;
+    currency: string;
+    /** The refund confirmed when the cancellation was created. Absent when the platform created it. */
+    expected_refundable_amount?: Money;
+    /** Present with `failed`: the owning service's code, such as for a disk that can only be released with its server. */
+    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 SubscriptionItemCancellationStatus = (typeof SubscriptionItemCancellationStatus)[keyof typeof SubscriptionItemCancellationStatus];
+export declare const SubscriptionItemCancellationStatus: {
+    readonly requested: "requested";
+    readonly scheduled: "scheduled";
+    readonly releasing: "releasing";
+    readonly failed: "failed";
+    readonly completed: "completed";
+    readonly canceled: "canceled";
+};
+/**
+ * The latest cancellation including the subscription item, with this item's entry: `id` is the entry and `cancellation_id` the cancellation. scheduled_at is the intended time and effective_at the confirmed end of service.
+ */
+export interface SubscriptionItemCancellation {
+    reason?: string;
+    /** The cancellation this entry belongs to, with the other items released together. */
+    cancellation_id?: string;
+    id: string;
+    subscription_item_id: string;
+    status: SubscriptionItemCancellationStatus;
+    mode: CancellationMode;
+    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;
+}
+export interface FieldViolation {
+    /** The path to the rejected field in the request body, such as `items[2].price_id`. */
+    field: string;
+    /** Why the field was rejected, such as `REQUIRED` or `OUT_OF_RANGE`. */
+    reason?: string;
+}
+/**
+ * Values that belong to `reason`, one set per reason. Clients use them to fill in
+ * localized text and never parse `message` to obtain them. Keys are documented per
+ * reason; a key that has appeared once keeps appearing.
+ */
+export type ErrorStatusMetadata = {
+    [key: string]: string;
+};
+export interface ErrorStatus {
+    /** The HTTP status code of the response. */
+    code: number;
+    /** The canonical name of the status, such as `INVALID_ARGUMENT` or `UNAVAILABLE`. */
+    status: string;
+    /**
+     * A description of the failure for developers. It is always English and is not meant
+     * to be shown to end users as is.
+     */
+    message: string;
+    /**
+     * A stable machine-readable code identifying the failure. Clients branch on this value
+     * and render their own text; it does not change once published.
+     */
+    reason?: string;
+    /**
+     * Values that belong to `reason`, one set per reason. Clients use them to fill in
+     * localized text and never parse `message` to obtain them. Keys are documented per
+     * reason; a key that has appeared once keeps appearing.
+     */
+    metadata?: ErrorStatusMetadata;
+    /**
+     * Request fields rejected by the request's constraints. Present on validation
+     * failures; one request may violate several fields.
+     */
+    field_violations?: FieldViolation[];
+    /**
+     * How long the client should wait before retrying, as a duration string such as
+     * `30s`. Present only when waiting can succeed.
+     */
+    retry_delay?: string;
+    /**
+     * The identifier of the request in the service's logs. Quote it when reporting a
+     * failure.
+     */
+    request_id?: string;
+}
+/**
+ * A failed request. The envelope follows the Google REST error format: `code` is the HTTP
+ * status, `status` is its canonical name, and `reason` is the stable machine-readable code
+ * that identifies the failure.
+ */
+export interface Error {
+    error: ErrorStatus;
+}
+/**
+ * The platform service's fixed 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;
+}
+/**
+ * Who suspended the account: `owner` (you), `operator` (Leaflow), or `none` while it is not suspended. Only a suspension by `owner` can be resumed by you.
+ */
+export type BillingAccountSuspendedBy = (typeof BillingAccountSuspendedBy)[keyof typeof BillingAccountSuspendedBy];
+export declare const BillingAccountSuspendedBy: {
+    readonly none: "none";
+    readonly owner: "owner";
+    readonly operator: "operator";
+};
+/**
+ * Whether the account is usable, suspended, or closed.
+ */
+export type BillingAccountStatus = (typeof BillingAccountStatus)[keyof typeof BillingAccountStatus];
+export declare const BillingAccountStatus: {
+    readonly active: "active";
+    readonly suspended: "suspended";
+    readonly closed: "closed";
+};
+export interface BillingAccount {
+    /**
+     * The active contact used for invoices, of this account; null clears it.
+     * @nullable
+     */
+    invoice_contact_id?: string | null;
+    id: number;
+    /** Your name for the account. */
+    name?: string;
+    /** Fixed when the account was opened. */
+    currency: string;
+    status: BillingAccountStatus;
+    /** Who suspended the account: `owner` (you), `operator` (Leaflow), or `none` while it is not suspended. Only a suspension by `owner` can be resumed by you. */
+    suspended_by: BillingAccountSuspendedBy;
+    /** How far past the suspension threshold the account may go before its resources are suspended; `0` means none. */
+    grace_amount?: string;
+    /** How long the account has to top up after crossing the suspension threshold, in seconds; `0` means none. Grace ends when this or grace_amount runs out. */
+    grace_period_seconds?: number;
+    /**
+     * When the account was closed. Null if it is not closed or the time is unknown.
+     * @nullable
+     */
+    readonly closed_at?: string | null;
+    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 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;
+}
+export interface BillingAccountUpdate {
+    /**
+     * The active contact used for invoices, of this account; null clears it.
+     * @nullable
+     */
+    invoice_contact_id?: string | null;
+    /** @maxLength 255 */
+    name?: string;
+}
+export interface BillingAccountList {
+    items: BillingAccount[];
+    pagination: OffsetPagination;
+}
+/**
+ * A plan referenced by an applicability; active is false once it is archived, and the reference still applies.
+ */
+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;
+}
+/**
+ * `per_unit` multiplies a unit amount; `tiered` walks a ladder.
+ */
+export type BillingScheme = (typeof BillingScheme)[keyof typeof BillingScheme];
+export declare const BillingScheme: {
+    readonly per_unit: "per_unit";
+    readonly tiered: "tiered";
+};
+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.
+ */
+export interface PriceOption {
+    product: Product;
+    plan: ObjectIdentity;
+    /** Absent when the price delegates to a rate card. */
+    billing_scheme?: BillingScheme;
+    unit_quantity: string;
+    id: string;
+    currency: string;
+    type: PriceType;
+    usage_type: UsageType;
+    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;
+}
+/**
+ * The purchase operation covered. `new`: every new purchase, including zero-charge ones; it does not mean the account's first purchase, which `first_purchase_only` restricts. `renew`: renewals. `modify`: configuration or billing-term changes, whether they charge, refund or neither.
+ */
+export type PurchaseOperation = (typeof PurchaseOperation)[keyof typeof PurchaseOperation];
+export declare const PurchaseOperation: {
+    readonly new: "new";
+    readonly renew: "renew";
+    readonly modify: "modify";
+};
+/**
+ * Covers anything not excluded that matches an inclusion, or anything not excluded when no inclusion is given, subject to the price type, usage type, operation and term conditions. Archived plans and prices stay listed with active false.
+ */
+export interface Applicability {
+    products?: Product[];
+    plans?: ApplicablePlan[];
+    prices?: PriceOption[];
+    /** The price types covered; empty covers both. */
+    price_types?: PriceType[];
+    /** The usage types covered; empty covers both. */
+    usage_types?: UsageType[];
+    operations?: PurchaseOperation[];
+    /** The shortest term a purchase may have, in months. Purchases without a term, such as metered usage, do not qualify 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;
+}
+/**
+ * Balance, credits and unpaid charges, each reported separately.
+ */
+export interface AccountBalance {
+    /** Balance minus pending balance returns and the part of unbilled_amount and due that estimated_credit_applied does not cover. Negative only when the balance and applicable credit fall short of what the account owes. */
+    available_credit: Money;
+    /** Credit expected to pay unbilled_amount and due, matching each charge to the grants whose scope, validity and conditions it meets, in the order credit is applied at payment. Nothing is deducted until an invoice is paid, so credits still includes this amount. */
+    estimated_credit_applied: Money;
+    /** Current estimate of priced usage that has not been invoiced. Final pricing and tax are fixed at issuance. */
+    unbilled_amount: Money;
+    billing_account_id: number;
+    currency: string;
+    /** Topped-up funds in the account's currency, excluding credits. May be negative after a payment dispute. Amounts owed are reported in due; this is not a withdrawable amount. */
+    balance: Money;
+    /** Remaining credit, including restricted grants; not withdrawable and not part of balance. credit_groups shows currently valid credit by permitted use; positive credits do not mean due is zero. */
+    credits: Money;
+    /** Currently valid credit restricted to certain products, operations or conditions; part of credits, not of balance. */
+    restricted_credits: Money;
+    /** Currently valid unspent credit grouped by permitted use. Each group covers only the charges its restrictions and validity allow, and the groups may differ from the recorded credits total. */
+    credit_groups: CreditGroup[];
+    /** Amount still payable on issued invoices. The invoice of an order not yet accepted is excluded, here and from available_credit. Usage not yet invoiced is reported separately. */
+    due: Money;
+    pending_returns_amount: Money;
+}
+/**
+ * `ARREARS`: the balance is negative. `PROJECTS_ASSIGNED`: the account still pays for a project, yours or anyone
+ * else's. `ACTIVE_SUBSCRIPTION`: a subscription it bought has not ended. `OPEN_ORDER`: an order is not finished.
+ * `UNPAID_INVOICE`: an issued invoice is not settled. `UNBILLED_USAGE`: usage has not been invoiced yet; it is
+ * invoiced in the next billing run. `PENDING_TRANSACTION`: a top-up, refund or withdrawal is still pending.
+ */
+export type AccountDeletionObjection = (typeof AccountDeletionObjection)[keyof typeof AccountDeletionObjection];
+export declare const AccountDeletionObjection: {
+    readonly ARREARS: "ARREARS";
+    readonly PROJECTS_ASSIGNED: "PROJECTS_ASSIGNED";
+    readonly ACTIVE_SUBSCRIPTION: "ACTIVE_SUBSCRIPTION";
+    readonly OPEN_ORDER: "OPEN_ORDER";
+    readonly UNPAID_INVOICE: "UNPAID_INVOICE";
+    readonly UNBILLED_USAGE: "UNBILLED_USAGE";
+    readonly PENDING_TRANSACTION: "PENDING_TRANSACTION";
+};
+export interface AccountDeletionReadinessItem {
+    account: BillingAccount;
+    /** Topped-up funds, in the account's currency, forfeited when it closes. Negative means arrears. */
+    balance: Money;
+    /** Remaining credit, in the account's currency, forfeited when it closes. */
+    credits: Money;
+    /** What stops this account from closing; empty when it can close. */
+    objections: AccountDeletionObjection[];
+}
+export interface AccountDeletionReadiness {
+    /** Every billing account you own that is not closed; empty when you own none. */
+    accounts: AccountDeletionReadinessItem[];
+}
+/**
+ * A project's assignment to a billing account from effective_from until effective_to; an open assignment has no end.
+ */
+export interface ProjectAssignment {
+    project_id: string;
+    /** The project and its current name. Absent when the project cannot be read; `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;
+}
+export interface AccountIdentity {
+    id: number;
+    name: string;
+    currency: string;
+}
+/**
+ * `pending` until the payment gateway reaches a result; the balance increases on `succeeded`. `failed`: the gateway declined the payment, which is withdrawn at the gateway; create a new top-up to pay another way. `canceled`: withdrawn without collecting money, for the reason in `cancellation_reason`. Unknown gateway outcomes stay `pending`; a browser redirect is not proof of payment. `failed` and `canceled` are final; a payment the gateway collects afterwards 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";
+};
+/**
+ * Why a gateway payment was withdrawn: `abandoned` when the customer did not complete it in time, `requested_by_customer` when 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 step; the payment outcome is reported separately.
+ */
+export interface PaymentAction {
+    type: PaymentActionType;
+    /** The browser adapter for the action, for example stripe. */
+    provider?: string;
+    url?: string;
+    /** QR content to render, not an image URL. */
+    qr_code?: string;
+    /** Short-lived client credential for confirming this payment in the browser. */
+    client_secret?: string;
+    public_key?: string;
+}
+/**
+ * A top-up attempt and its outcome. A successful top-up adds to the balance; it is not a credit grant and has no invoice.
+ */
+export interface TopUp {
+    id: string;
+    billing_account_id: number;
+    account: AccountIdentity;
+    /** What is credited to the account, in its currency. */
+    amount: Money;
+    currency: string;
+    /** The part of this top-up still in the balance. Pending refunds may hold part of it, so not all of it is necessarily withdrawable. */
+    remaining_amount?: Money;
+    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 charged in when the checkout collected a local currency; absent when it is the account's. */
+    presentment_currency?: string;
+    /** The amount charged in `presentment_currency`, as shown on the customer's statement. */
+    presentment_amount?: Money;
+    /** Why the gateway declined it; present with `failed`. The gateway's code unchanged: the issuer's decline code when there is one (Stripe decline_code, such as insufficient_funds), otherwise the gateway's error code (Stripe code, such as card_declined). Treat an unknown value as a generic decline. */
+    failure_reason?: string;
+    action?: PaymentAction;
+    created_at: string;
+    /**
+     * When the funds arrived, possibly days after `created_at`. Absent until the payment completes.
+     * @nullable
+     */
+    settled_at?: string | null;
+}
+export interface TopUpCreate {
+    /**
+     * The gateway 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 top-up ID, chosen by the caller. Read it after an uncertain response. */
+    id: string;
+    billing_account_id: number;
+    /** In the account's currency, no finer than its smallest unit (two decimals for most currencies, none for JPY). An amount below the currency's minimum top-up is refused, and the minimum is returned with the error. */
+    amount: Money & string;
+    /** Charge a saved payment 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 this method type can be saved with create-payment-method-setup and charged later without the customer. */
+    reusable: boolean;
+}
+/**
+ * A gateway accepting the account's currency, with its payment methods.
+ */
+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 to collect a card in the page; the card goes from the browser straight to the gateway.
+ */
+export interface PaymentMethodSetupResult {
+    /** The gateway's identifier for this 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.
+ *
+ * `payment_gateway` and `method_type` are given together, and `payment_method_id` only with both;
+ * otherwise the request is refused with `BILLING_PURCHASE_INVALID`.
+ */
+export interface PayInvoiceRequest {
+    /**
+     * Required to collect an online remainder. An existing attempt keeps its 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;
+    /** A saved card of this billing account at the selected gateway. Omit to pay interactively. */
+    payment_method_id?: string;
+    /** Whether to apply the balance; credit grants are controlled by use_credits. */
+    use_balance?: boolean;
+    /** Apply eligible, unexpired credit grants before the balance. Grants are never converted into balance. */
+    use_credits?: boolean;
+    return_url?: string;
+}
+/**
+ * Name at least one invoice or order. All must belong to one account in its currency.
+ */
+export interface PayTogetherRequest {
+    /** @maxItems 100 */
+    invoice_ids?: string[];
+    /** @maxItems 100 */
+    order_ids?: string[];
+    /** The amount due across all invoices, before credit grants or balance, as preview-pay-together gave it. A different amount fails with `BILLING_AMOUNT_CHANGED` and nothing is charged. Omit to skip the check. */
+    expected_amount?: Money & string;
+}
+/**
+ * `succeeded`: paid. `processing`: confirmation is pending; poll the invoice or order instead of paying again. `requires_action`: the customer must complete the returned action. `failed`: the attempt did not succeed, for the reason in failure_reason; a declined gateway payment is withdrawn, and paying again starts a new payment.
+ */
+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;
+}
+/**
+ * Account funding for this purchase, calculated by Billing. Amounts use the enclosing response currency.
+ * Credit eligibility and all purchase requirements are already evaluated. Nothing is charged or reserved.
+ * A licensed purchase may instead be paid with an online payment method.
+ */
+export interface Funds {
+    /** Spendable balance after pending returns. */
+    available_balance_amount: Money;
+    /** Currently effective credits eligible for the purchases being checked out or metered usage. Each grant is counted once. */
+    usable_credit_amount: Money;
+    /** Currently effective credits that cannot fund any purchase being checked out or metered target. Unused eligible credits are not restricted. */
+    restricted_credit_amount: Money;
+    /** Minimum spendable balance needed after eligible credits, covering immediate charges and every new metered purchase's admission requirement. */
+    required_balance_amount: Money;
+    /** Additional balance needed now. Zero means account funds satisfy this purchase. No funds are reserved. */
+    balance_shortfall_amount: Money;
+    /** Minimum recharge that covers the shortfall, respecting the currency minimum recharge and currency precision. Zero when no additional balance is needed. */
+    required_top_up_amount: Money;
+}
+/**
+ * What paying would take, calculated as paying does. Nothing is charged or reserved.
+ */
+export interface PaymentPreview {
+    funds?: Funds;
+    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 used. */
+    credit_grants: AppliedCredit[];
+    /** What the balance would pay. */
+    balance_applied: Money;
+    /** What would remain to pay 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 payment order. */
+    invoices?: PaymentPreviewInvoice[];
+}
+/**
+ * Present on refunds: where this part goes. `balance`: the account balance. `credit`: the credit grant that paid, keeping its original expiry. `gateway`: 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`: the operation did not succeed; for a gateway payment, the gateway declined it. `canceled`: a gateway payment was withdrawn without collecting money. Either way, the invoice it was for stays open.
+ */
+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; 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 adjustment: "adjustment";
+    readonly fee: "fee";
+};
+/**
+ * A funds movement with one source. Refunds name the original transaction. Unknown gateway results stay pending.
+ */
+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 goes. `balance`: the account balance. `credit`: the credit grant that paid, keeping its original expiry. `gateway`: the payment method it was paid with. */
+    refund_destination?: TransactionRefundDestination;
+    status?: TransactionStatus;
+    cancellation_reason?: PaymentCancellationReason;
+    payment_gateway?: string;
+    method_type?: string;
+    /** Why it failed; present with `failed`. For a declined gateway payment, the gateway's code unchanged: the issuer's decline code when there is one (Stripe decline_code, such as insufficient_funds), otherwise the gateway's error code (Stripe code, such as card_declined). 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`. An `adjustment` is positive when it adds to the balance and negative when it takes from it. For other types the sign does not show the effect on the balance: a payment from balance lowers it, a payment by gateway or credit does not. */
+    amount: Money;
+    /** How much of this transaction is still in the balance. Only top-ups, positive adjustments and gateway payments 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. */
+    transaction_id?: string;
+    status: PaymentStatus;
+    amount_paid: Money;
+    /** What is still outstanding: zero once the payment succeeds, unchanged while `processing`. */
+    amount_due: Money;
+    currency: string;
+    credit_applied?: Money;
+    gateway_amount?: Money;
+    payment_gateway?: string;
+    method_type?: string;
+    /** The amount already paid from balance toward this invoice; retrying the online remainder does not debit it again. */
+    balance_applied?: Money;
+    action?: PaymentAction;
+    /** Whether paying again can succeed. False for a refusal that will repeat, such as a closed account or an amount over a limit. */
+    retriable?: boolean;
+    /** @nullable */
+    invoice_id?: string | null;
+    /** @nullable */
+    order_id?: string | null;
+    /** Why the payment failed; present with `failed`. For a declined gateway payment, the gateway's code unchanged: the issuer's decline code when there is one (Stripe decline_code, such as insufficient_funds), otherwise the gateway's error code (Stripe code, such as card_declined). Treat an unknown value as a generic decline. */
+    failure_reason?: string;
+}
+/**
+ * `open`: issued and not yet settled; a zero-total invoice is paid at once. `paid` stays paid after a refund, with the refunded part in amount_refunded. `void`: collection has stopped and any funds received have been returned. Usage not yet invoiced is not on any invoice.
+ */
+export type InvoiceStatus = (typeof InvoiceStatus)[keyof typeof InvoiceStatus];
+export declare const InvoiceStatus: {
+    readonly open: "open";
+    readonly paid: "paid";
+    readonly void: "void";
+};
+/**
+ * How tax applied to the customer when the invoice was issued; `reverse` means no tax was charged under the reverse-charge mechanism.
+ */
+export type InvoiceCustomerTaxExempt = (typeof InvoiceCustomerTaxExempt)[keyof typeof InvoiceCustomerTaxExempt];
+export declare const InvoiceCustomerTaxExempt: {
+    readonly none: "none";
+    readonly exempt: "exempt";
+    readonly reverse: "reverse";
+};
+/**
+ * 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 {
+    /** Collection has stopped; accepted return obligations are completed. */
+    void_requested_at?: string;
+    due_at?: string;
+    amount_refunded?: string;
+    tax_items: TaxItem[];
+    id: string;
+    billing_account_id: number;
+    /** Numbered per account and per month. */
+    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?: Money;
+    /** Sum of the line discounts, taken off before tax. */
+    discount_amount?: Money;
+    tax_amount?: Money;
+    /** Successful credit-grant payments, included in amount_paid; they do not reduce the receivable or tax base. */
+    credit_applied?: Money;
+    /** Subtotal less discount plus tax. Balance and credit grants pay it plus rounding_amount; they do not reduce it. */
+    total: Money;
+    /** Added to total to round the amount payable to the currency's minor unit; negative when rounded down. The rounding of a usage invoice carries over to the next invoice of the same billing period. */
+    rounding_amount: Money;
+    amount_paid?: Money;
+    /** Issued credit notes that reduced unpaid receivables; the original invoice total is unchanged. */
+    pre_payment_credit_notes_amount: Money;
+    /** Issued credit notes against payments already received; their refunds may not have completed. */
+    post_payment_credit_notes_amount: Money;
+    /** What is still collectible from total plus rounding_amount after unpaid credit notes and successful payments; never below zero. Zero for a paid or void invoice. */
+    amount_due: Money;
+    /** @nullable */
+    period_start?: string | null;
+    /**
+     * Exclusive.
+     * @nullable
+     */
+    period_end?: string | null;
+    /** The billing details recorded when the invoice was issued. */
+    customer_name?: string;
+    customer_email?: string;
+    customer_tax_id?: string;
+    /** How tax applied to the customer when the invoice was issued; `reverse` means no tax was charged under the reverse-charge mechanism. */
+    customer_tax_exempt?: InvoiceCustomerTaxExempt;
+    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;
+}
+/**
+ * For a usage line, the values of its meter's presentation dimensions, such as the model and token kind. Empty for other lines.
+ */
+export type InvoiceItemDimensions = {
+    [key: string]: string;
+};
+/**
+ * The value of one paid period moved to the new configuration of a subscription item.
+ */
+export interface InvoiceItemProration {
+    /** The earlier invoice line that paid for the period. */
+    credited_invoice_item_id: string;
+    /** The earlier invoice line's wording as recorded. */
+    description: string;
+    period_start: string;
+    /** Exclusive. */
+    period_end: string;
+    /** Before tax and discounts, the new configuration for the period. */
+    remaining_amount: Money;
+    /** Before tax, the unused value of the earlier line for the period, credited against `remaining_amount`. */
+    credited_amount: Money;
+}
+export interface InvoiceItem {
+    taxable?: boolean;
+    /** Discount applied to this line before tax. */
+    discount_amount?: string;
+    /**
+     * The account discount applied to this line.
+     * @nullable
+     */
+    discount_id?: string | null;
+    /**
+     * The coupon applied to this line.
+     * @nullable
+     */
+    coupon_id?: string | null;
+    /** 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;
+    id: string;
+    /** @nullable */
+    project_id?: string | null;
+    /** The project the charge was for and its current name. Absent when the line has no project or the project cannot be read; `project_id` still identifies it. */
+    project?: NamedIdentity | null;
+    resource_id?: string;
+    /** The line's wording as recorded when the invoice was issued. */
+    description: string;
+    unit?: string;
+    quantity?: string;
+    /** The part covered by an included allowance, and therefore not charged. */
+    deducted_quantity?: string;
+    unit_amount?: Money;
+    /** The quantity `unit_amount` prices, such as 1000000 tokens or 3600 seconds: `amount` is `quantity` × `unit_amount` ÷ `unit_quantity`. Present together with `unit_amount`. */
+    unit_quantity?: string;
+    amount: Money;
+    /** This line's share of the invoice's rounding_amount. The line's net amount is amount - discount_amount + tax_amount - tax_included_amount + rounding_amount. */
+    rounding_amount: Money;
+    /** Usage charges billed on this line; zero for other lines. */
+    usage_charge_count: number;
+    currency: string;
+    /** @nullable */
+    period_start?: string | null;
+    /** @nullable */
+    period_end?: string | null;
+    /** For a usage line, the values of its meter's presentation dimensions, such as the model and token kind. Empty for other lines. */
+    dimensions?: InvoiceItemDimensions;
+    /**
+     * Present on a line that changes a subscription item immediately, one entry for each paid period it
+     * covers. `amount` is the sum of `remaining_amount` minus `credited_amount` over the entries.
+     */
+    prorations?: InvoiceItemProration[];
+}
+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;
+}
+/**
+ * Why the note was issued. Notes for canceled, expired or failed orders carry the order's reason; `usage_true_up` returns a tier price reduction settled after the original invoice; `operator` was issued on request.
+ */
+export type CreditNoteReason = (typeof CreditNoteReason)[keyof typeof CreditNoteReason];
+export declare const CreditNoteReason: {
+    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 usage_true_up: "usage_true_up";
+    readonly operator: "operator";
+};
+export type CreditNoteStatus = (typeof CreditNoteStatus)[keyof typeof CreditNoteStatus];
+export declare const CreditNoteStatus: {
+    readonly issued: "issued";
+    readonly void: "void";
+};
+/**
+ * A reduction of an issued invoice; the original invoice amounts do not change. The credited amount is pre_payment_amount plus post_payment_amount. A paid part creates a refund, identified by refund_id, whose outcome may still be pending.
+ */
+export interface CreditNote {
+    id: string;
+    invoice_id: string;
+    currency: string;
+    issued_at: string;
+    status: CreditNoteStatus;
+    /**
+     * When this note was voided; null while issued.
+     * @nullable
+     */
+    voided_at: string | null;
+    /** The reduction of unpaid receivables. A void note no longer reduces what is due. */
+    pre_payment_amount: Money;
+    /** The credited part of payments already received; its refund may not have completed. */
+    post_payment_amount: Money;
+    /**
+     * The refund to the original payment sources; null when no paid amount was credited.
+     * @nullable
+     */
+    refund_id: string | null;
+    /** Why the note was issued. Notes for canceled, expired or failed orders carry the order's reason; `usage_true_up` returns a tier price reduction settled after the original invoice; `operator` was issued on request. */
+    reason: CreditNoteReason;
+}
+export interface CreditNoteItem {
+    id: string;
+    credit_note_id: string;
+    invoice_item_id: string;
+    pre_payment_amount: Money;
+    post_payment_amount: Money;
+}
+export interface CreditNoteList {
+    items: CreditNote[];
+    pagination: OffsetPagination;
+}
+export interface CreditNoteItemList {
+    items: CreditNoteItem[];
+    pagination: OffsetPagination;
+}
+/**
+ * Use balance_amount, credit_amount and gateway_amount, which also show a refund split between 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. New codes may be added; treat an unknown code as unspecified.
+ *
+ * - `provisioning_failed`: the purchase could not be delivered.
+ * - `order_expired`: the order expired after part of it was paid.
+ * - `order_canceled`: the order was canceled after part of it was paid.
+ * - `change_canceled`: a scheduled change was withdrawn after part of it was paid.
+ * - `change_expired`: a scheduled change could not take effect in time.
+ * - `subscription_canceled`: the unused value of a canceled subscription item, under its refund terms.
+ * - `future_period_canceled`: a renewal that had not started was withdrawn.
+ * - `downgrade_difference`: after a downgrade, the remaining paid value, valued under each paid period's refund
+ *   policy and as `prorated` where that policy is `none`, minus the new configuration's value for the remaining
+ *   time: each whole month at the change item's `monthly_list_amount` and the remainder in proportion to the
+ *   length of the month it falls in, or without `monthly_list_amount`, the new period price in proportion to the
+ *   remaining time.
+ * - `usage_true_up`: usage priced 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_item_id?: string;
+    /** The refund split by original payment source, with each result. Unknown gateway results stay 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 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 destinations.
+     * @deprecated
+     */
+    destination?: RefundDestination;
+    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 dimension values the rate was matched by, such as region and machine type.
+ */
+export type UsageChargeDimensions = {
+    [key: string]: string;
+};
+export interface UsageCharge {
+    /** The subscription item the usage belongs to. */
+    subscription_item_id: string;
+    /** The subscription the item belongs to. */
+    subscription_id: string;
+    id: string;
+    project_id?: string;
+    /** The project and its current name. Absent when the project cannot be read; `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 dimension values the rate was matched by, such as region and machine type. */
+    dimensions?: UsageChargeDimensions;
+    window_start: string;
+    /** Exclusive. */
+    window_end: string;
+    /** Quantity used before allowances. */
+    gross_quantity?: string;
+    /** How much of that was covered by an allowance. */
+    deducted_quantity?: string;
+    /** The quantity charged: gross quantity less the part covered by allowances. */
+    quantity: string;
+    unit_amount?: Money;
+    /** The quantity `unit_amount` prices, such as 1000000 tokens or 3600 seconds: `amount` is `quantity` × `unit_amount` ÷ `unit_quantity`. */
+    unit_quantity?: string;
+    amount: Money;
+    currency: string;
+    /**
+     * Present after the statement is closed and its invoice is issued.
+     * @nullable
+     */
+    invoice_id?: string | null;
+    /**
+     * Present after the statement is closed and its invoice is issued.
+     * @nullable
+     */
+    invoice_item_id?: string | null;
+    /** The statement this charge was collected into. */
+    statement_id?: string;
+}
+export interface UsageChargeList {
+    items: UsageCharge[];
+    pagination: OffsetPagination;
+}
+/**
+ * `pending`: the order has not been accepted. `provisioning`: the owning service accepted the order and is delivering. `active`: delivery was confirmed; payment alone does not make a subscription active. `trialing`: in a free trial, in service, with its licensed items not charged until `trial_end`; metered usage is charged as usual. `suspended`: service is stopped while a lien restricts its use. `canceled`: cancellation of every item completed, or an undelivered purchase was canceled or failed. `terminated`: an operator or the owning service ended it immediately.
+ */
+export type SubscriptionStatus = (typeof SubscriptionStatus)[keyof typeof SubscriptionStatus];
+export declare const SubscriptionStatus: {
+    readonly pending: "pending";
+    readonly provisioning: "provisioning";
+    readonly active: "active";
+    readonly trialing: "trialing";
+    readonly suspended: "suspended";
+    readonly canceled: "canceled";
+    readonly terminated: "terminated";
+};
+/**
+ * The renewal term of its licensed items, `interval_count` intervals long; `none` when every item is metered.
+ */
+export type SubscriptionInterval = (typeof SubscriptionInterval)[keyof typeof SubscriptionInterval];
+export declare const SubscriptionInterval: {
+    readonly none: "none";
+    readonly day: "day";
+    readonly month: "month";
+    readonly year: "year";
+};
+/**
+ * What happens when the trial ends while automatic renewal is off. With it on, the first paid period is charged to the account's funds or saved payment method, and this applies only when that charge fails. `cancel`: the subscription ends and its resources are released. `pause`: service stops, and renewing before the retention period ends restores it, with the first paid period starting at payment. `create_invoice`: as `pause`, and an invoice for the first paid period is issued to pay.
+ */
+export type TrialEndBehaviorMissingPaymentMethod = (typeof TrialEndBehaviorMissingPaymentMethod)[keyof typeof TrialEndBehaviorMissingPaymentMethod];
+export declare const TrialEndBehaviorMissingPaymentMethod: {
+    readonly cancel: "cancel";
+    readonly pause: "pause";
+    readonly create_invoice: "create_invoice";
+};
+export interface TrialEndBehavior {
+    /** What happens when the trial ends while automatic renewal is off. With it on, the first paid period is charged to the account's funds or saved payment method, and this applies only when that charge fails. `cancel`: the subscription ends and its resources are released. `pause`: service stops, and renewing before the retention period ends restores it, with the first paid period starting at payment. `create_invoice`: as `pause`, and an invoice for the first paid period is issued to pay. */
+    missing_payment_method: TrialEndBehaviorMissingPaymentMethod;
+    /**
+     * How long a subscription stopped at the end of its trial keeps its resources before they are reclaimed; null for the platform's retention period.
+     * @nullable
+     */
+    retention_seconds: number | null;
+}
+/**
+ * How a free trial ends, as Stripe's trial_settings.
+ */
+export interface TrialSettings {
+    end_behavior: TrialEndBehavior;
+}
+/**
+ * An operation prevented on the subscription. `billing.subscriptions.use` stops the service. `renew` prevents renewal and paying a renewal order. `modify` prevents placing a change order. `cancel` prevents cancellation. `terminate` prevents immediate termination.
+ */
+export type SubscriptionRestriction = (typeof SubscriptionRestriction)[keyof typeof SubscriptionRestriction];
+export declare const SubscriptionRestriction: {
+    readonly billingsubscriptionsuse: "billing.subscriptions.use";
+    readonly billingsubscriptionsrenew: "billing.subscriptions.renew";
+    readonly billingsubscriptionsmodify: "billing.subscriptions.modify";
+    readonly billingsubscriptionscancel: "billing.subscriptions.cancel";
+    readonly billingsubscriptionsterminate: "billing.subscriptions.terminate";
+};
+/**
+ * Follows the items. `pending`: not yet accepted, paid or unpaid; its invoice shows whether payment is needed, and it can expire or be canceled. `accepted`: items are being set up. `completed`: every item was set up. `partially_completed`: some items were set up and the others failed or were canceled and refunded to their original payment sources. `failed`: no item was delivered and at least one failed; amounts collected for undelivered items are refunded. `canceled`: every item was withdrawn without delivery; collected amounts are returned to their original payment sources. No status by itself means the service was delivered.
+ */
+export type OrderStatus = (typeof OrderStatus)[keyof typeof OrderStatus];
+export declare const OrderStatus: {
+    readonly pending: "pending";
+    readonly accepted: "accepted";
+    readonly completed: "completed";
+    readonly partially_completed: "partially_completed";
+    readonly failed: "failed";
+    readonly canceled: "canceled";
+};
+export type ScheduledChangeInterval = (typeof ScheduledChangeInterval)[keyof typeof ScheduledChangeInterval];
+export declare const ScheduledChangeInterval: {
+    readonly day: "day";
+    readonly month: "month";
+    readonly year: "year";
+};
+/**
+ * The next accepted period-end change of the item: the target terms, applied at effective_at.
+ */
+export interface ScheduledChange {
+    order_id: string;
+    status: OrderStatus;
+    /** When the target terms take effect, normally the end of the current paid period. */
+    effective_at: string;
+    plan_id: string;
+    plan_name: string;
+    price_id: string;
+    quantity: string;
+    /** The target licensed renewal amount before tax. */
+    recurring_amount: string;
+    currency: string;
+    interval: ScheduledChangeInterval;
+    /** @minimum 1 */
+    interval_count: number;
+}
+/**
+ * The dimension values of what was bought, such as region and instance type. Empty when the purchase gave none.
+ */
+export type SubscriptionItemDimensions = {
+    [key: string]: string;
+};
+/**
+ * One priced part of a subscription, as a Stripe subscription item, such as the instance, a volume or the bandwidth of an elastic IP. It renews with its subscription and can be changed or canceled alone.
+ */
+export interface SubscriptionItem {
+    id: string;
+    subscription_id: string;
+    plan_id: string;
+    plan_name: string;
+    price_id: string;
+    type: PriceType;
+    usage_type: UsageType;
+    /** The dimension values of what was bought, such as region and instance type. Empty when the purchase gave none. */
+    dimensions: SubscriptionItemDimensions;
+    quantity: string;
+    /** This item's renewal amount, after continuing discounts and before tax. A pending item shows base terms until paying the order fixes any new discount. Absent for metered and one-time items. */
+    recurring_amount?: string;
+    /** Whether new account discounts may apply to this item in future renewals. A fixed operator renewal agreement disables automatic discounts; catalog repricing or a newly selected purchase agreement enables them. */
+    renewal_discounts_enabled?: boolean;
+    cancellation_policy?: CancellationPolicy;
+    refund_policy?: RefundPolicy;
+    /** Refund policy `short_rate` only, as on the price bought. */
+    short_rate_multiplier?: string;
+    /** Refund policy `short_rate` only, as on the price bought. */
+    short_rate_threshold_seconds?: number;
+    /** Licensed recurring only, the `monthly_list_amount` that a renewal at the agreed amount keeps; see the order item. */
+    monthly_list_amount?: string;
+    coupon_id?: string;
+    coupon?: ObjectIdentity;
+    /** @minimum 0 */
+    discounted_renewals_remaining?: number;
+    /** The order item that created it. */
+    order_item_id?: string;
+    cancellation?: SubscriptionItemCancellation;
+    /** The accepted period-end change scheduled for this item; null when there is none. */
+    scheduled_change?: ScheduledChange | null;
+    created_at?: string;
+    /**
+     * When the item's service started. Null until its delivery is confirmed.
+     * @nullable
+     */
+    started_at?: string | null;
+    /**
+     * When the item ended, alone or with its subscription.
+     * @nullable
+     */
+    ended_at?: string | null;
+}
+/**
+ * A billing relationship that renews as a whole, as a Stripe subscription: one term, one renewal date, one
+ * automatic renewal setting and one service state for all of its items. The owning service decides which order
+ * lines form one subscription, such as a machine and the volumes and elastic IP bought with it; a resource bought
+ * on its own has its own. A purchase creates pending subscriptions and items whose IDs are returned on the order
+ * items and stay the same through checkout, delivery, renewals and changes.
+ *
+ * Pending and provisioning subscriptions grant no service. A subscription becomes provisioning when the owning
+ * service accepts the order, and active, or trialing during a free trial, when the service confirms delivery,
+ * which sets started_at; payment changes neither. Renewing buys further periods for every continuing licensed
+ * item at once; items cannot be renewed on their own, but each can be changed or canceled alone.
+ */
+export interface Subscription {
+    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;
+    product: Product;
+    /**
+     * The project it is for. Absent for an account-level purchase, such as a membership.
+     * @nullable
+     */
+    project_id?: string | null;
+    /** The project and its current name. Absent for an account-level purchase or when the project cannot be read; `project_id` still identifies it. */
+    project?: NamedIdentity | null;
+    currency: string;
+    status: SubscriptionStatus;
+    /** The renewal term of its licensed items, `interval_count` intervals long; `none` when every item is metered. */
+    interval: SubscriptionInterval;
+    /** @minimum 1 */
+    interval_count?: number;
+    /**
+     * When the subscription renews or expires: the end of the free trial or of the last period bought for its licensed items, moved by renewing in advance. Null until the subscription becomes active, even when its purchase has been paid, and when every item is metered.
+     * @nullable
+     */
+    current_term_end?: string | null;
+    /**
+     * Start of the service period in effect now. Null when none is, including when every item is metered.
+     * @nullable
+     */
+    current_period_start?: string | null;
+    /**
+     * End of the service period in effect now; renewing in advance moves `current_term_end`, not this. Null when no period is in effect, including when every item is metered.
+     * @nullable
+     */
+    current_period_end?: string | null;
+    billing_cycle_anchor?: string;
+    /** Whether the subscription renews automatically, or converts to paid when its free trial ends. Without licensed items it continues until it is canceled; then this is true until a cancellation is requested, and cannot be set. */
+    auto_renew: boolean;
+    /**
+     * Start of the free trial; null without one. During the trial the licensed items are free, while metered usage is charged as usual.
+     * @nullable
+     */
+    trial_start?: string | null;
+    /**
+     * End of the free trial; null without one. It is `current_term_end` until the first paid period is bought.
+     * @nullable
+     */
+    trial_end?: string | null;
+    /** How the free trial ends; null without one. */
+    trial_settings?: TrialSettings | null;
+    /** The operations currently prevented on the subscription, sorted; it is suspended while this contains `billing.subscriptions.use`. */
+    restrictions?: SubscriptionRestriction[];
+    /**
+     * The saved payment method automatic renewal charges after balance and credits, before the account's default payment method. Set when a purchase, renewal or change is paid with a saved payment method. Used only while it belongs to the account paying the renewal.
+     * @nullable
+     */
+    default_payment_method_id?: string | null;
+    /** Every item, ended ones included, oldest first. */
+    items: SubscriptionItem[];
+    created_at?: string;
+    /**
+     * When service started. Null until a new subscription becomes active, also after payment.
+     * @nullable
+     */
+    started_at?: string | null;
+    /** @nullable */
+    ended_at?: string | null;
+}
+export interface SubscriptionList {
+    items: Subscription[];
+    pagination: OffsetPagination;
+}
+export type RenewalOptionInterval = (typeof RenewalOptionInterval)[keyof typeof RenewalOptionInterval];
+export declare const RenewalOptionInterval: {
+    readonly day: "day";
+    readonly month: "month";
+    readonly year: "year";
+};
+/**
+ * What one item renews at under a renewal option.
+ */
+export interface RenewalOptionItem {
+    subscription_item_id: string;
+    /**
+     * The price the item renews at; null on the current option, which keeps the agreed amount.
+     * @nullable
+     */
+    price_id: string | null;
+    /** One period of this item, before tax and discounts. */
+    amount: Money;
+    cancellation_policy?: CancellationPolicy;
+    refund_policy?: RefundPolicy;
+    /** Refund policy `short_rate` only. */
+    short_rate_multiplier?: string;
+    /** Refund policy `short_rate` only. */
+    short_rate_threshold_seconds?: number;
+}
+/**
+ * One term the whole subscription can renew for. Every continuing licensed item renews at it; items with an open cancellation end with the current term and are left out.
+ */
+export interface RenewalOption {
+    interval: RenewalOptionInterval;
+    /** How many intervals one renewal covers. */
+    interval_count: number;
+    /** The term the subscription renews at now; renewing for it keeps every item's agreed price. */
+    current: boolean;
+    /** One period for every item, before tax and discounts. */
+    amount: Money;
+    currency: string;
+    items: RenewalOptionItem[];
+}
+export interface RenewalOptionList {
+    items: RenewalOption[];
+    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 {
+    /** The order ID, chosen by the caller. Creating it again conflicts; read the order after an unknown outcome. */
+    order_id: string;
+    /**
+     * How many further periods to buy for every renewed item, each at the price it already renews at. To buy a longer term at its own price, give `interval` and `interval_count` instead.
+     * @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 every item at the price it 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 every item is bought at today's price for that term, with its own cancellation
+     * policy or, without one, the only price of that term. Naming the current term changes
+     * nothing. A term an item does not sell is refused with 409 `BILLING_RENEWAL_PRICE_UNAVAILABLE`
+     * and `meta.subscription_item_id`; prices the rule cannot choose between, with 409
+     * `BILLING_RENEWAL_OPTION_AMBIGUOUS` unless `cancellation_policy` is given.
+     *
+     * List the terms on offer with the renewal options operation.
+     * @minimum 1
+     */
+    interval_count?: number;
+    /** The unit interval_count counts in. */
+    interval?: RenewRequestInterval;
+    /** With `interval` and `interval_count`, renews every item at its price of that term with this cancellation policy. */
+    cancellation_policy?: CancellationPolicy;
+    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;
+}
+/**
+ * The settings to change; settings left out keep their values.
+ */
+export interface SubscriptionUpdate {
+    auto_renew?: boolean;
+}
+/**
+ * "`open`: waiting for you to complete checkout; nothing is ordered, invoiced or reserved. `complete`:
+ * the order and its issued invoice exist; read the order for payment and delivery. `expired`: ended without an
+ * order."
+ */
+export type CheckoutSessionStatus = (typeof CheckoutSessionStatus)[keyof typeof CheckoutSessionStatus];
+export declare const CheckoutSessionStatus: {
+    readonly open: "open";
+    readonly complete: "complete";
+    readonly expired: "expired";
+};
+/**
+ * "`new` buys, `renew` extends subscriptions, `modify` changes subscription items' configuration or
+ * billing terms."
+ */
+export type CheckoutSessionType = (typeof CheckoutSessionType)[keyof typeof CheckoutSessionType];
+export declare const CheckoutSessionType: {
+    readonly new: "new";
+    readonly renew: "renew";
+    readonly modify: "modify";
+};
+/**
+ * When a change takes effect, as on the order it creates; `none` for anything that is not a change.
+ */
+export type CheckoutSessionChangeEffective = (typeof CheckoutSessionChangeEffective)[keyof typeof CheckoutSessionChangeEffective];
+export declare const CheckoutSessionChangeEffective: {
+    readonly none: "none";
+    readonly immediate: "immediate";
+    readonly period_end: "period_end";
+};
+/**
+ * "`complete`: tax is calculated for the billing account's invoice contact, or for `address` in a preview
+ * without an account. `requires_location_inputs`: a preview without an account or `address`, which leaves out
+ * tax that would be added; tax already contained in a price is included."
+ */
+export type CheckoutSessionTaxStatus = (typeof CheckoutSessionTaxStatus)[keyof typeof CheckoutSessionTaxStatus];
+export declare const CheckoutSessionTaxStatus: {
+    readonly complete: "complete";
+    readonly requires_location_inputs: "requires_location_inputs";
+};
+/**
+ * automatic completes checkout with the purchase: the best applicable account discount is applied, and the
+ * order is created with its invoice issued and paid from eligible credit grants and available balance.
+ * Insufficient funds fail the purchase with HTTP 422 BILLING_INSUFFICIENT_FUNDS; no Billing order, charge or
+ * discount redemption is committed.
+ * deferred creates an open Billing Checkout Session and charges nothing, even for a zero total. The customer
+ * completes it through Billing, where a promotion code can be applied, and then pays the issued invoice; a
+ * session not completed by its deadline expires.
+ */
+export type CheckoutMode = (typeof CheckoutMode)[keyof typeof CheckoutMode];
+export declare const CheckoutMode: {
+    readonly automatic: "automatic";
+    readonly deferred: "deferred";
+};
+/**
+ * Shared checkout choices for a product purchase. The service may set them or forward its client's
+ * choices unchanged; it does not need to read them, and Billing validates them. Omitting this object or
+ * mode selects automatic checkout. Each purchase creates its own Checkout Session. Promotion codes are supplied
+ * only to Billing. A service may retain a failed creation record when Billing refuses a purchase; no
+ * infrastructure is created for that refusal.
+ */
+export interface CheckoutOptions {
+    mode?: CheckoutMode;
+    /**
+     * Expected invoice total after discounts and tax, before applying credit grants or balance.
+     * A different total fails with BILLING_AMOUNT_CHANGED without charging or reserving a discount.
+     * Accepted only in automatic mode; with deferred it is refused with HTTP 400. For deferred
+     * checkout, give the expected amount when completing it through Billing.
+     */
+    expected_amount?: Money & string;
+    /**
+     * Where the client goes after the customer finishes a deferred checkout. Any absolute URI with a
+     * scheme, including mobile and desktop application schemes. Billing stores it without checking the
+     * target; each client validates its own.
+     * @maxLength 2048
+     */
+    return_url?: string;
+    /**
+     * Turns on automatic renewal of every subscription with licensed items that the purchase opens. Off
+     * when omitted. It must be the customer's own choice. For a free trial, it converts the trial to paid
+     * when the trial ends.
+     */
+    auto_renew?: boolean;
+    /**
+     * A free trial grant of the paying billing account that the customer chose to use. The first new
+     * subscription of the purchase whose lines the grant's offer all covers, and that has a licensed line and
+     * no trial of its own, opens with the offer's free trial. Accepted only in automatic mode; with deferred it is refused with
+     * HTTP 400, and the grant is chosen when completing the checkout through Billing. Refused with
+     * BILLING_TRIAL_GRANT_INAPPLICABLE when no subscription qualifies or the grant cannot be used now.
+     */
+    trial_grant_id?: string;
+}
+export type CheckoutSessionDiscountType = (typeof CheckoutSessionDiscountType)[keyof typeof CheckoutSessionDiscountType];
+export declare const CheckoutSessionDiscountType: {
+    readonly promotion_code: "promotion_code";
+    readonly account_discount: "account_discount";
+};
+/**
+ * "Whether the discount continues on renewals of what is bought: `once` applies only to this
+ * purchase, `recurring` for `frequency_duration` periods including the first, `forever` on every renewal."
+ */
+export type CheckoutSessionDiscountFrequency = (typeof CheckoutSessionDiscountFrequency)[keyof typeof CheckoutSessionDiscountFrequency];
+export declare const CheckoutSessionDiscountFrequency: {
+    readonly once: "once";
+    readonly recurring: "recurring";
+    readonly forever: "forever";
+};
+/**
+ * "`confirmed`: every condition of the discount holds for the billing account. `unverified`: a preview
+ * without an account, where conditions that depend on the account, such as a first purchase or a per-account
+ * limit, are checked only when a session is completed."
+ */
+export type CheckoutSessionDiscountEligibility = (typeof CheckoutSessionDiscountEligibility)[keyof typeof CheckoutSessionDiscountEligibility];
+export declare const CheckoutSessionDiscountEligibility: {
+    readonly confirmed: "confirmed";
+    readonly unverified: "unverified";
+};
+/**
+ * The discount a session gets. It is redeemed only when the session completes.
+ */
+export interface CheckoutSessionDiscount {
+    type: CheckoutSessionDiscountType;
+    name: string;
+    /**
+     * Code text for a promotion_code discount; null for an account_discount.
+     * @minLength 1
+     * @maxLength 64
+     * @nullable
+     */
+    promotion_code: string | null;
+    /**
+     * "Whether the discount continues on renewals of what is bought: `once` applies only to this
+     * purchase, `recurring` for `frequency_duration` periods including the first, `forever` on every renewal."
+     */
+    frequency: CheckoutSessionDiscountFrequency;
+    /**
+     * For `recurring`, the periods the discount lasts; null otherwise.
+     * @minimum 1
+     * @nullable
+     */
+    frequency_duration: number | null;
+    /**
+     * "`confirmed`: every condition of the discount holds for the billing account. `unverified`: a preview
+     * without an account, where conditions that depend on the account, such as a first purchase or a per-account
+     * limit, are checked only when a session is completed."
+     */
+    eligibility: CheckoutSessionDiscountEligibility;
+}
+/**
+ * The terms of a free trial. The licensed items of the subscription it is used for are free for `trial_period_days`, while metered usage is charged as usual. When the trial ends it converts to paid if automatic renewal is on; otherwise `trial_settings` applies.
+ */
+export interface TrialOffer {
+    id: string;
+    name: string;
+    description: string;
+    /**
+     * @minimum 1
+     * @maximum 730
+     */
+    trial_period_days: number;
+    trial_settings: TrialSettings;
+    /** The purchases it can be used for. Every line of the subscription must be covered. */
+    applies_to: Applicability;
+}
+/**
+ * `scheduled` before valid_from, `available` to be chosen at checkout, `redeemed` once used for a subscription, `expired` after valid_until without being used, or `voided` once withdrawn.
+ */
+export type TrialGrantStatus = (typeof TrialGrantStatus)[keyof typeof TrialGrantStatus];
+export declare const TrialGrantStatus: {
+    readonly scheduled: "scheduled";
+    readonly available: "available";
+    readonly redeemed: "redeemed";
+    readonly expired: "expired";
+    readonly voided: "voided";
+};
+/**
+ * One free trial held by a billing account for a period. It is used for one subscription; if the order it was used for is canceled or fails, it can be used again while it is valid.
+ */
+export interface TrialGrant {
+    id: string;
+    billing_account_id: number;
+    trial_offer: TrialOffer;
+    status: TrialGrantStatus;
+    valid_from: string;
+    /**
+     * Null when the grant does not expire.
+     * @nullable
+     */
+    valid_until: string | null;
+    /** @nullable */
+    voided_at: string | null;
+    /**
+     * The order the grant was used for; null until it is used.
+     * @nullable
+     */
+    order_id: string | null;
+    /**
+     * The subscription the grant was used for; null until it is used.
+     * @nullable
+     */
+    subscription_id: string | null;
+    /** @nullable */
+    redeemed_at: string | null;
+}
+/**
+ * Settings of a subscription a purchase opens, as Stripe Checkout's subscription_data.
+ */
+export interface SubscriptionData {
+    /**
+     * A free trial of this many days; null without one or when given as `trial_end`.
+     * @minimum 1
+     * @maximum 730
+     * @nullable
+     */
+    trial_period_days: number | null;
+    /**
+     * The end of the free trial; null without one or when given in days.
+     * @nullable
+     */
+    trial_end: string | null;
+    /** How the free trial ends; null without a trial. */
+    trial_settings: TrialSettings | null;
+}
+/**
+ * A free trial a subscription opens with. Its licensed items are free until `trial_end`; metered usage is
+ * charged as usual. For an open session the times are as if it were completed now.
+ */
+export interface CheckoutSessionTrial {
+    trial_start: string;
+    trial_end: string;
+    trial_settings: TrialSettings;
+}
+/**
+ * The term every item of the subscription renews for, for renewals; `none` otherwise.
+ */
+export type CheckoutSessionSubscriptionInterval = (typeof CheckoutSessionSubscriptionInterval)[keyof typeof CheckoutSessionSubscriptionInterval];
+export declare const CheckoutSessionSubscriptionInterval: {
+    readonly none: "none";
+    readonly day: "day";
+    readonly month: "month";
+    readonly year: "year";
+};
+/**
+ * The billing period of a recurring licensed price; `none` otherwise, and when `price_id` is null.
+ */
+export type CheckoutSessionItemInterval = (typeof CheckoutSessionItemInterval)[keyof typeof CheckoutSessionItemInterval];
+export declare const CheckoutSessionItemInterval: {
+    readonly none: "none";
+    readonly day: "day";
+    readonly month: "month";
+    readonly year: "year";
+};
+/**
+ * What an immediate downgrade would refund, estimated as of `proration_date`. The refund itself is determined
+ * when the change takes effect.
+ */
+export interface CheckoutSessionItemDowngradeRefund {
+    /** Returned to the original payment sources, tax paid on it included. */
+    refundable_amount: Money;
+    /** Before tax, the part of the excess that the item's refund terms do not return. */
+    forfeited_amount: Money;
+}
+/**
+ * The dimension values of what is bought, such as region and instance type.
+ */
+export type CheckoutSessionItemDimensions = {
+    [key: string]: string;
+};
+/**
+ * One item of the session; it becomes the order item at the same position. Its price is selected as when
+ * checkout completes, and amounts are this item's share of the session's.
+ */
+export interface CheckoutSessionItem {
+    /**
+     * Counted across the session's subscriptions in order, starting from zero.
+     * @minimum 0
+     */
+    position: number;
+    /**
+     * The subscription item changed or renewed. Null for an item the purchase adds.
+     * @nullable
+     */
+    subscription_item_id: string | null;
+    product_id: ProductId;
+    plan_id: string;
+    plan_name: string;
+    /**
+     * The price the item is charged under: the one it named, or the one selected by billing terms or from the
+     * subscription item changed or renewed. Null for an expired session whose item did not name one.
+     * @nullable
+     */
+    price_id: string | null;
+    /** The price type; null when `price_id` is. */
+    type: PriceType | null;
+    /** The usage type; null when `price_id` is. */
+    usage_type: UsageType | null;
+    /** The billing period of a recurring licensed price; `none` otherwise, and when `price_id` is null. */
+    interval: CheckoutSessionItemInterval;
+    /**
+     * Periods per billing cycle of a recurring licensed price; null otherwise.
+     * @minimum 1
+     * @nullable
+     */
+    interval_count: number | null;
+    quantity: string;
+    /** The dimension values of what is bought, such as region and instance type. */
+    dimensions: CheckoutSessionItemDimensions;
+    /**
+     * Renewals only; null otherwise. How many consecutive periods are renewed.
+     * @minimum 1
+     * @nullable
+     */
+    periods: number | null;
+    /** Unit price before discounts. Null when no single unit price applies, such as tiered or multiple-rate pricing. */
+    unit_amount: Money | null;
+    /** The setup charge already included in `amount`; null when none applies. */
+    setup_amount: Money | null;
+    /**
+     * Recurring licensed items only; null otherwise. What each later period renews at, before discounts and
+     * tax, which differs from `amount` when the first period is priced differently, such as in a free trial. The
+     * session's `discount` says whether its discount continues on renewals.
+     */
+    recurring_amount: Money | null;
+    /** Amount before discounts, including any setup charge. */
+    amount: Money | null;
+    /** Total reduction on this item, including any continuing renewal discount. */
+    discount_amount: Money | null;
+    /** Tax on the discounted amount, including any tax already contained in that amount. */
+    tax_amount: Money | null;
+    /** The part of tax_amount already contained in amount minus discount_amount. */
+    tax_included_amount: Money | null;
+    /** amount minus discount_amount plus tax_amount minus tax_included_amount. */
+    total: Money | null;
+    /**
+     * Immediate changes only; null otherwise. Before tax, the new terms for the time from `proration_date` to
+     * the end of the paid period. An upgrade invoices `remaining_amount` minus `unused_amount`.
+     */
+    remaining_amount: Money | null;
+    /**
+     * Immediate changes only; null otherwise. Before tax, for an upgrade or an unchanged period price, the
+     * amount paid for that time, up to the new terms' value for the same time; for a downgrade, the remaining value
+     * of what was paid, under the refund terms of each paid period.
+     */
+    unused_amount: Money | null;
+    /** Immediate downgrades only, when `unused_amount` exceeds `remaining_amount`; null otherwise. */
+    downgrade_refund: CheckoutSessionItemDowngradeRefund | null;
+}
+/**
+ * One subscription of the session and its items, with its share of the session's amounts.
+ */
+export interface CheckoutSessionSubscription {
+    /**
+     * The existing subscription renewed or changed, or that new items are added to. Null for a subscription the purchase opens.
+     * @nullable
+     */
+    subscription_id: string | null;
+    /** The settings the owning service gave a subscription the purchase opens; null without any. */
+    subscription_data: SubscriptionData | null;
+    /**
+     * The free trial grant this subscription uses, saved on an open session or used by a complete one; null otherwise.
+     * @nullable
+     */
+    trial_grant_id: string | null;
+    /** The free trial the subscription opens with, from `subscription_data` or the trial grant. Null without one, and for an expired session. */
+    trial: CheckoutSessionTrial | null;
+    /** The term every item of the subscription renews for, for renewals; `none` otherwise. */
+    interval: CheckoutSessionSubscriptionInterval;
+    /**
+     * Renewals only; null otherwise.
+     * @minimum 1
+     * @nullable
+     */
+    interval_count: number | null;
+    /**
+     * Renewals only; null otherwise. How many consecutive terms are renewed.
+     * @minimum 1
+     * @nullable
+     */
+    periods: number | null;
+    /** The items' amounts before discounts, including any setup charge. */
+    amount: Money | null;
+    discount_amount: Money | null;
+    /** Tax on the discounted amount, including any tax already contained in it. */
+    tax_amount: Money | null;
+    /** The part of `tax_amount` already contained in `amount` minus `discount_amount`. */
+    tax_included_amount: Money | null;
+    /** amount minus discount_amount plus tax_amount minus tax_included_amount; this subscription's share of the session's `total`. */
+    total: Money | null;
+    /** The subscription's items, in order. */
+    items: CheckoutSessionItem[];
+}
+/**
+ * A purchase, a change of subscriptions or their renewal, waiting for checkout to be completed, and what
+ * completing it invoices. Completing it applies the choices saved on it and creates the order with its invoice
+ * issued; the order carries the session's ID. A preview returns the same object without saving it.
+ *
+ * Amounts are what completing an open session would invoice at the time it is read, and for a complete session
+ * those of its order's invoice. An expired session has no amounts; they are null.
+ */
+export interface CheckoutSession {
+    /**
+     * Null in a preview.
+     * @nullable
+     */
+    id: string | null;
+    product_id: ProductId;
+    /**
+     * Null in a preview without an account.
+     * @nullable
+     */
+    billing_account_id: number | null;
+    /** Null in a preview without an account. */
+    account: AccountIdentity | null;
+    /**
+     * The project the purchase is for. Null for an account-level purchase, such as a membership, and in a preview.
+     * @nullable
+     */
+    project_id: string | null;
+    /**
+     * The project and its current name. Null when `project_id` is, or when the project cannot be read;
+     * `project_id` still identifies it.
+     */
+    project: NamedIdentity | null;
+    /**
+     * "`new` buys, `renew` extends subscriptions, `modify` changes subscription items' configuration or
+     * billing terms."
+     */
+    type: CheckoutSessionType;
+    /** When a change takes effect, as on the order it creates; `none` for anything that is not a change. */
+    change_effective: CheckoutSessionChangeEffective;
+    /** `open` in a preview. */
+    status: CheckoutSessionStatus;
+    currency: string;
+    /**
+     * The checkout choices, as the purchase gave them and as you saved them since. Billing does not check
+     * `return_url`; validate it before navigating.
+     */
+    checkout: CheckoutOptions;
+    /**
+     * The promotion code saved on the session, or used to complete it; null without one.
+     * @nullable
+     */
+    promotion_code: string | null;
+    /** The discount the session gets, from its promotion code or otherwise the best applicable account discount. Null when there is none, and for an expired session. */
+    discount: CheckoutSessionDiscount | null;
+    /** Sum before discounts, excluding tax already included in the item amounts. */
+    subtotal: Money | null;
+    /** Total item discounts. */
+    discount_amount: Money | null;
+    /** Total tax on the discounted amounts. */
+    tax_amount: Money | null;
+    /** subtotal minus discount_amount plus tax_amount, before credit grants and balance. Confirm an open session with it as `expected_amount`. */
+    total: Money | null;
+    /**
+     * "`complete`: tax is calculated for the billing account's invoice contact, or for `address` in a preview
+     * without an account. `requires_location_inputs`: a preview without an account or `address`, which leaves out
+     * tax that would be added; tax already contained in a price is included."
+     */
+    tax_status: CheckoutSessionTaxStatus;
+    /**
+     * Immediate changes and items added to an existing subscription of an open session only; null otherwise.
+     * The instant they are priced from; confirm the session with it so it is priced from the same instant.
+     * @nullable
+     */
+    proration_date: string | null;
+    /** Account funds for completing an open session; null for other sessions and without an account. */
+    funds: Funds | null;
+    /**
+     * The free trial grants of the account that the session can use now, soonest to expire first. Empty for a
+     * session that is not open, without an account, and for changes and renewals.
+     */
+    trial_grants: TrialGrant[];
+    /**
+     * When an open session expires; null in a preview. The order a complete session created has its own payment deadline.
+     * @nullable
+     */
+    expires_at: string | null;
+    /**
+     * Null in a preview.
+     * @nullable
+     */
+    created_at: string | null;
+    /** @nullable */
+    completed_at: string | null;
+    /** @nullable */
+    expired_at: string | null;
+    /**
+     * The order created when the session completed. Null otherwise.
+     * @nullable
+     */
+    order_id: string | null;
+    /** The subscriptions the session buys, renews or changes, in order, each with its items. */
+    subscriptions: CheckoutSessionSubscription[];
+}
+export interface CheckoutSessionList {
+    items: CheckoutSession[];
+    pagination: OffsetPagination;
+}
+/**
+ * Settings of a subscription a previewed purchase opens, as the owning service would give them.
+ */
+export interface SubscriptionDataInput {
+    /**
+     * Give this or `trial_end`, not both.
+     * @minimum 1
+     * @maximum 730
+     */
+    trial_period_days?: number;
+    trial_end?: string;
+    trial_settings?: TrialSettings;
+}
+/**
+ * `new` previews a purchase, `modify` a change of subscription items, `renew` a renewal.
+ */
+export type CheckoutSessionPreviewRequestType = (typeof CheckoutSessionPreviewRequestType)[keyof typeof CheckoutSessionPreviewRequestType];
+export declare const CheckoutSessionPreviewRequestType: {
+    readonly new: "new";
+    readonly renew: "renew";
+    readonly modify: "modify";
+};
+/**
+ * For `modify` only; defaults to `immediate`. `immediate` prices the rest of the paid period from
+ * `proration_date`, charging an upgrade the difference and showing what a downgrade refunds. `period_end`
+ * prices the first period at the new terms, which replaces the renewal when the paid period ends.
+ */
+export type CheckoutSessionPreviewRequestChangeEffective = (typeof CheckoutSessionPreviewRequestChangeEffective)[keyof typeof CheckoutSessionPreviewRequestChangeEffective];
+export declare const CheckoutSessionPreviewRequestChangeEffective: {
+    readonly immediate: "immediate";
+    readonly period_end: "period_end";
+};
+/**
+ * For `renew` only, as in creating a renewal Checkout Session.
+ */
+export type CheckoutSessionPreviewRequestInterval = (typeof CheckoutSessionPreviewRequestInterval)[keyof typeof CheckoutSessionPreviewRequestInterval];
+export declare const CheckoutSessionPreviewRequestInterval: {
+    readonly day: "day";
+    readonly month: "month";
+    readonly year: "year";
+};
+/**
+ * Where a customer is, for the tax that would be added there.
+ */
+export interface CustomerAddress {
+    /**
+     * ISO 3166-1 alpha-2, two uppercase letters.
+     * @pattern ^[A-Z]{2}$
+     */
+    country: string;
+    /**
+     * The state or province, as the tax rates name it.
+     * @minLength 1
+     * @maxLength 128
+     */
+    state?: string;
+}
+export type CheckoutSessionItemInputInterval = (typeof CheckoutSessionItemInputInterval)[keyof typeof CheckoutSessionItemInputInterval];
+export declare const CheckoutSessionItemInputInterval: {
+    readonly none: "none";
+    readonly day: "day";
+    readonly month: "month";
+    readonly year: "year";
+};
+/**
+ * The dimension values of what is bought, such as region and instance type, or after a change, given in full. Required whenever the price uses a rate card; prices with their own amounts ignore them. Every key the meter declares must be given. A combination no rate covers is refused with `BILLING_PRICE_UNAVAILABLE` rather than priced at zero. Prices are set per currency, and a currency may not offer some combinations at all, for example in a region it does not sell to.
+ */
+export type CheckoutSessionItemInputDimensions = {
+    [key: string]: string;
+};
+/**
+ * Identify a price, or select one for a plan; give each resource's ID or lookup key, never both, and
+ * product_id with lookup keys. A change names its `subscription_item_id`; without a price or billing terms the
+ * plan's price with the item's price type, usage type, interval, interval count and cancellation policy is
+ * selected, and omitted dimensions keep the item's. A metered item includes only any setup charge; its usage is
+ * estimated with `estimate-usage`.
+ */
+export interface CheckoutSessionItemInput {
+    /** For `modify` only. The subscription item changed. */
+    subscription_item_id?: string;
+    /**
+     * @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 price type. */
+    price_type?: PriceType;
+    /** Narrows the selection when a plan offers more than one usage type. */
+    usage_type?: UsageType;
+    interval?: CheckoutSessionItemInputInterval;
+    /** @minimum 1 */
+    interval_count?: number;
+    /** Selects among licensed prices with otherwise identical billing terms. Ambiguous terms are refused instead of choosing a price arbitrarily. */
+    cancellation_policy?: CancellationPolicy;
+    /**
+     * The quantity bought, or after a change.
+     * @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;
+    /** The dimension values of what is bought, such as region and instance type, or after a change, given in full. Required whenever the price uses a rate card; prices with their own amounts ignore them. Every key the meter declares must be given. A combination no rate covers is refused with `BILLING_PRICE_UNAVAILABLE` rather than priced at zero. Prices are set per currency, and a currency may not offer some combinations at all, for example in a region it does not sell to. */
+    dimensions?: CheckoutSessionItemInputDimensions;
+}
+/**
+ * One subscription of the previewed session. For `new`, give its items, with `subscription_id` to add them to
+ * that existing subscription and otherwise optionally `subscription_data`; for `modify`, the subscription and the
+ * items changed; for `renew`, only the subscription.
+ */
+export interface CheckoutSessionPreviewSubscription {
+    subscription_id?: string;
+    /**
+     * @minItems 1
+     * @maxItems 100
+     */
+    items?: CheckoutSessionItemInput[];
+    subscription_data?: SubscriptionDataInput;
+}
+/**
+ * The session to preview, as it would be created. Give exactly one of `billing_account_id` and `currency`;
+ * changes, renewals, items added to an existing subscription and trial grants need the account. A request that
+ * does not fit `type` fails with `BILLING_PURCHASE_INVALID` and the field.
+ */
+export interface CheckoutSessionPreviewRequest {
+    /** `new` previews a purchase, `modify` a change of subscription items, `renew` a renewal. */
+    type: CheckoutSessionPreviewRequestType;
+    /**
+     * The billing account to price for; it must be yours or currently pay for a project you are a member of, and an access token is required. Subscriptions changed or renewed must currently be paid by it.
+     * @minimum 1
+     */
+    billing_account_id?: number;
+    /**
+     * For `new` only. The ISO 4217 currency to price in without an account.
+     * @minLength 3
+     * @maxLength 3
+     */
+    currency?: string;
+    /**
+     * Only with `currency`. Where the customer is, to include the tax that would be added there for a customer
+     * who is not tax exempt; `tax_status` is then `complete`. Refused with `billing_account_id`, whose invoice
+     * contact decides tax.
+     */
+    address?: CustomerAddress;
+    /**
+     * For `modify` only; defaults to `immediate`. `immediate` prices the rest of the paid period from
+     * `proration_date`, charging an upgrade the difference and showing what a downgrade refunds. `period_end`
+     * prices the first period at the new terms, which replaces the renewal when the paid period ends.
+     */
+    change_effective?: CheckoutSessionPreviewRequestChangeEffective;
+    /**
+     * At most 100 items in all for `new` and `modify`, and each subscription at most once for `renew`.
+     * @minItems 1
+     * @maxItems 100
+     */
+    subscriptions: CheckoutSessionPreviewSubscription[];
+    /**
+     * For `renew` only, as in creating a renewal Checkout Session.
+     * @minimum 1
+     */
+    periods?: number;
+    /**
+     * For `renew` only, as in creating a renewal Checkout Session.
+     * @minimum 1
+     */
+    interval_count?: number;
+    /** For `renew` only, as in creating a renewal Checkout Session. */
+    interval?: CheckoutSessionPreviewRequestInterval;
+    /** For `renew` only, as in creating a renewal Checkout Session. */
+    cancellation_policy?: CancellationPolicy;
+    /**
+     * For `new` and `modify`. Evaluated without being applied.
+     * @minLength 1
+     * @maxLength 64
+     */
+    promotion_code?: string;
+    /** For `new` with `billing_account_id`. A free trial grant of the account to preview the purchase with. */
+    trial_grant_id?: string;
+}
+/**
+ * Give at least one choice. Saving a choice equal to the current one changes nothing.
+ */
+export interface CheckoutSessionUpdate {
+    /**
+     * The promotion code to complete the session with; null removes it, and the best applicable account discount applies instead.
+     * @minLength 1
+     * @maxLength 64
+     * @nullable
+     */
+    promotion_code?: string | null;
+    /**
+     * A free trial grant of the session's billing account to use; null removes it.
+     * @nullable
+     */
+    trial_grant_id?: string | null;
+    /** Turns on or off automatic renewal of every subscription with licensed items the session opens. It must be your own choice. */
+    auto_renew?: boolean;
+}
+/**
+ * As in renewing.
+ */
+export type CheckoutSessionCreateInterval = (typeof CheckoutSessionCreateInterval)[keyof typeof CheckoutSessionCreateInterval];
+export declare const CheckoutSessionCreateInterval: {
+    readonly day: "day";
+    readonly month: "month";
+    readonly year: "year";
+};
+/**
+ * One subscription to renew.
+ */
+export interface CheckoutSessionSubscriptionInput {
+    subscription_id: string;
+}
+/**
+ * The subscriptions to renew together, and the periods and price chosen as in renewing, applied to each.
+ */
+export interface CheckoutSessionCreate {
+    /** Chosen by the caller. Creating it again conflicts; read the session after an unknown outcome. */
+    checkout_session_id: string;
+    /**
+     * Each subscription at most once.
+     * @minItems 1
+     * @maxItems 20
+     */
+    subscriptions: CheckoutSessionSubscriptionInput[];
+    /**
+     * As in renewing.
+     * @minimum 1
+     */
+    periods?: number;
+    /**
+     * As in renewing.
+     * @minimum 1
+     */
+    interval_count?: number;
+    /** As in renewing. */
+    interval?: CheckoutSessionCreateInterval;
+    /** As in renewing. */
+    cancellation_policy?: CancellationPolicy;
+}
+export interface CheckoutSessionConfirm {
+    /** The session's `total` as read, after discounts and tax and before credit grants or balance. */
+    expected_amount: Money & string;
+    /**
+     * Immediate changes and items added to an existing subscription only. The session's `proration_date` as
+     * read; it must be a whole second, not in the future and at most 10 minutes old, otherwise the request is
+     * refused with `BILLING_CHANGE_INVALID`. Defaults to the time of the request.
+     */
+    proration_date?: string;
+}
+/**
+ * An order's invoice amounts, without contact details or payment methods, issued when the order is created; a zero-total invoice is paid at once.
+ */
+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;
+    /** Issued credit notes that reduced unpaid receivables; the original invoice total is unchanged. */
+    pre_payment_credit_notes_amount: Money;
+    /** Issued credit notes against payments already received; their refunds may not have completed. */
+    post_payment_credit_notes_amount: Money;
+    /**
+     * What is still collectible after unpaid credit notes and successful payments; never below zero.
+     * @pattern ^\d+(\.\d{1,10})?$
+     */
+    amount_due: string;
+    amount_refunded: string;
+    due_at?: string;
+}
+/**
+ * How it was paid. `payment_method_id` still names the payment method after it is removed.
+ */
+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;
+}
+/**
+ * `new` buys, `renew` extends subscriptions, `modify` changes subscription items' configuration or billing terms.
+ */
+export type OrderType = (typeof OrderType)[keyof typeof OrderType];
+export declare const OrderType: {
+    readonly new: "new";
+    readonly renew: "renew";
+    readonly modify: "modify";
+};
+/**
+ * When a plan change takes effect; `none` for anything that is not a change. A `period_end` order stays pending until the first period at the new price is paid. That period is invoiced when the order is created and starts when the current paid period ends; if the invoice is unpaid by then, the order is canceled and the item renews or ends with its subscription as usual.
+ */
+export type OrderChangeEffective = (typeof OrderChangeEffective)[keyof typeof OrderChangeEffective];
+export declare const OrderChangeEffective: {
+    readonly none: "none";
+    readonly immediate: "immediate";
+    readonly period_end: "period_end";
+};
+export type OrderItemInterval = (typeof OrderItemInterval)[keyof typeof OrderItemInterval];
+export declare const OrderItemInterval: {
+    readonly none: "none";
+    readonly day: "day";
+    readonly month: "month";
+    readonly year: "year";
+};
+/**
+ * `pending`: waiting to be set up. `completed`: set up, as confirmed by the service. `failed`: not set up; its amount was refunded to the original payment sources. `canceled`: withdrawn without delivery; any collected amount is returned. A completed item ends when its subscription item is canceled.
+ */
+export type OrderItemStatus = (typeof OrderItemStatus)[keyof typeof OrderItemStatus];
+export declare const OrderItemStatus: {
+    readonly pending: "pending";
+    readonly completed: "completed";
+    readonly failed: "failed";
+    readonly canceled: "canceled";
+};
+export type OrderItemConfiguration = {
+    [key: string]: unknown;
+};
+/**
+ * The dimension values the line was bought with, such as region and instance type. Empty when the purchase gave none.
+ */
+export type OrderItemDimensions = {
+    [key: string]: string;
+};
+/**
+ * The purchase terms frozen at placement. Monetary fields come from the order's invoice lines and are zero without an immediate charge, such as for a metered purchase. Later catalog changes do not reprice the line. A new service purchase has its pending subscription and subscription item from placement.
+ */
+export interface OrderItem {
+    /** Whether new account discounts may apply to future renewals. A fixed operator renewal agreement disables automatic discounts; catalog repricing or a newly selected purchase agreement enables them. */
+    renewal_discounts_enabled?: boolean;
+    /** Financial lines produced by this purchase item, including setup charges. */
+    invoice_item_ids?: string[];
+    /** @minimum 0 */
+    position?: number;
+    configuration?: OrderItemConfiguration;
+    /** The Billing subscription the line belongs to: a new pending one, the existing one an added item joins, or the one renewed or changed, which keeps its ID. Absent for a purchase without a subscription. */
+    subscription_id?: string;
+    /** The subscription item the line created, renewed or changed, which keeps its ID. Absent for a purchase without a subscription. */
+    subscription_item_id?: string;
+    interval: OrderItemInterval;
+    /** @minimum 1 */
+    interval_count?: number;
+    cancellation_policy?: CancellationPolicy;
+    refund_policy?: RefundPolicy;
+    /**
+     * Recurring licensed items only: a month at list price for this item's quantity, before tax and discounts, which values time under a refund or a downgrade. It is the monthly amount of the shortest period the plan sells, not longer than the one bought, at the item's dimensions, fixed at purchase; a renewal at the agreed amount keeps the previous value. Null when time used is valued at the amount paid, as for a daily period.
+     * @nullable
+     */
+    monthly_list_amount?: string | null;
+    /**
+     * Refund policy `short_rate` only, as on the price when bought.
+     * @nullable
+     */
+    short_rate_multiplier?: string | null;
+    /**
+     * Refund policy `short_rate` only, as on the price when bought.
+     * @nullable
+     */
+    short_rate_threshold_seconds?: number | null;
+    recurring_amount?: string;
+    setup_amount?: string;
+    type: PriceType;
+    usage_type: UsageType;
+    /** The dimension values the line was bought with, such as region and instance type. Empty when the purchase gave none. */
+    dimensions: OrderItemDimensions;
+    /** 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;
+    /** The name when bought. */
+    plan_name: string;
+    quantity: string;
+    /** The unit amount of the price the line is charged under. Absent for a tiered price, and for an immediate change, which is charged as `gross_amount` describes. */
+    unit_amount?: Money;
+    /**
+     * Before discounts and setup fees: the price applied to the quantity, `unit_amount` times `quantity` for a per-
+     * unit price, raised by any minimum charge. For an immediate upgrade it is the new price for the rest of the
+     * paid period minus the amount paid for that time; a downgrade, or a change between equal period prices, charges
+     * nothing.
+     *
+     * Under an inclusive tax rate it includes tax, shown in `tax_included_amount`, except for a renewal at agreed
+     * terms, whose amount excludes tax.
+     */
+    gross_amount?: Money;
+    /** The reduction on this line, from the order's coupon and, for a renewal at agreed terms, from the subscription's carried discount. With a carried discount, `gross_amount` is `unit_amount` times `quantity`, except when the renewal order also uses an account coupon or the tax rate is inclusive: then `gross_amount` is the agreed amount, which already reflects the carried discount. */
+    discount_amount?: Money;
+    /** `gross_amount` less `discount_amount`. */
+    amount?: Money;
+    currency: string;
+    /**
+     * The start of the service period this line paid for. Fixed at placement for renewals and period-end changes, and for a licensed line of a new purchase when its invoice is paid. Absent for metered and one-time lines.
+     * @nullable
+     */
+    period_start?: string | null;
+    /**
+     * The end of that service period, exclusive.
+     * @nullable
+     */
+    period_end?: string | null;
+    status: OrderItemStatus;
+}
+/**
+ * A recorded purchase, created with its invoice issued when its Checkout Session completes or when Billing renews a subscription. A zero-total invoice, such as for a metered purchase, is paid at once. Coupon fields describe the discount applied then. Payment and acceptance do not mean the resources were delivered.
+ */
+export interface Order {
+    coupon_id?: string;
+    coupon?: ObjectIdentity;
+    promotion_code_id?: string;
+    /** The promotion code applied. Absent for an account discount. */
+    promotion_code?: string;
+    /** The order's invoice, the same as invoice.id. */
+    invoice_id: string;
+    invoice: InvoiceSummary;
+    /** How the order was paid. Absent until it is paid. */
+    paid_with?: PaidWith;
+    account?: AccountIdentity;
+    change_effective_at?: string;
+    id: string;
+    /**
+     * The project it was bought for. Absent for an account-level purchase, such as a membership.
+     * @nullable
+     */
+    project_id?: string | null;
+    /** The project and its current name. Absent for an account-level purchase or when the project cannot be read; `project_id` still identifies it. */
+    project?: NamedIdentity | null;
+    /** The billing account the order was placed with, unchanged when the project is later linked to another account. While it is suspended or closed, the order cannot be accepted, and a period-end change is called off when the current period ends; such requests fail with `BILLING_ACCOUNT_UNAVAILABLE`. */
+    billing_account_id?: number;
+    currency: string;
+    /** `new` buys, `renew` extends subscriptions, `modify` changes subscription items' configuration or billing terms. */
+    type: OrderType;
+    status: OrderStatus;
+    /** When a plan change takes effect; `none` for anything that is not a change. A `period_end` order stays pending until the first period at the new price is paid. That period is invoiced when the order is created and starts when the current paid period ends; if the invoice is unpaid by then, the order is canceled and the item renews or ends with its subscription as usual. */
+    change_effective?: OrderChangeEffective;
+    /**
+     * Acceptance deadline; a pending order expires after it.
+     * @nullable
+     */
+    expires_at?: string | null;
+    /**
+     * The Checkout Session that created the order. Null for orders Billing creates itself, such as automatic renewals.
+     * @nullable
+     */
+    checkout_session_id?: string | null;
+    created_at: string;
+    /** What was bought. */
+    items: OrderItem[];
+}
+/**
+ * The complete session and the order it created.
+ */
+export interface CheckoutSessionResult {
+    checkout_session: CheckoutSession;
+    order: Order;
+}
+export interface OrderList {
+    items: Order[];
+    pagination: OffsetPagination;
+}
+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";
+};
+/**
+ * Whether the discount continues on renewals: `once` applies only to the purchase or renewal using the coupon, `recurring` for `frequency_duration` periods including the first, `forever` on every renewal.
+ */
+export type DiscountFrequency = (typeof DiscountFrequency)[keyof typeof DiscountFrequency];
+export declare const DiscountFrequency: {
+    readonly once: "once";
+    readonly recurring: "recurring";
+    readonly forever: "forever";
+};
+/**
+ * `scheduled` before valid_from, `active` within the validity, `expired` after valid_until, or `voided` once withdrawn.
+ */
+export type DiscountStatus = (typeof DiscountStatus)[keyof typeof DiscountStatus];
+export declare const DiscountStatus: {
+    readonly scheduled: "scheduled";
+    readonly active: "active";
+    readonly expired: "expired";
+    readonly voided: "voided";
+};
+/**
+ * A coupon held by the account for a period, applying without a code to the purchases and metered usage it covers.
+ */
+export interface Discount {
+    min_amount?: string;
+    billing_account_id?: number;
+    coupon_id: string;
+    promotion_code_id?: string;
+    status: DiscountStatus;
+    voided_at?: string;
+    type: DiscountType;
+    /** Whether the discount continues on renewals: `once` applies only to the purchase or renewal using the coupon, `recurring` for `frequency_duration` periods including the first, `forever` on every renewal. */
+    frequency?: DiscountFrequency;
+    /** @minimum 1 */
+    frequency_duration?: 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 pay for. Absent means anything on the account, including setup fees and usage. */
+    applies_to: Applicability;
+    /** Restricted to your first purchase of anything it applies to. */
+    first_purchase_only?: boolean;
+    valid_from?: string;
+    /**
+     * Absent follows the coupon's own validity.
+     * @nullable
+     */
+    valid_until?: string | null;
+}
+export interface DiscountList {
+    items: Discount[];
+    pagination: OffsetPagination;
+}
+export interface TrialGrantList {
+    items: TrialGrant[];
+    pagination: OffsetPagination;
+}
+export interface OrderItemList {
+    items: OrderItem[];
+    pagination: OffsetPagination;
+}
+/**
+ * Whether the quantity was paid for or granted free; both are consumed the same way.
+ */
+export type AllowanceCategory = (typeof AllowanceCategory)[keyof typeof AllowanceCategory];
+export declare const AllowanceCategory: {
+    readonly paid: "paid";
+    readonly promotional: "promotional";
+};
+/**
+ * Exact values for a subset of the meter's dimensions. Only usage with these values is deducted;
+ * omitted dimensions are not restricted.
+ */
+export type AllowanceDimensions = {
+    [key: string]: string;
+};
+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;
+    /** The subscription item whose purchase includes the allowance; absent for an allowance not included in a purchase. */
+    subscription_item_id?: string;
+    /** The subscription that item belongs to. */
+    subscription_id?: string;
+    id: string;
+    billing_account_id?: number;
+    product: Product;
+    meter: ObjectIdentity;
+    /** The unit it is counted in, such as `MiB`. */
+    unit?: string;
+    /** Whether the quantity was paid for or granted free; both are consumed the same way. */
+    category: AllowanceCategory;
+    /**
+     * Exact values for a subset of the meter's dimensions. Only usage with these values is deducted;
+     * omitted dimensions are not restricted.
+     */
+    dimensions: AllowanceDimensions;
+    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. */
+    priority?: number;
+    status: AllowanceStatus;
+    valid_from: string;
+    /**
+     * When the allowance lapses; unused quantity is lost. Absent when it does not expire.
+     * @nullable
+     */
+    valid_until?: string | null;
+}
+export interface AllowanceList {
+    items: Allowance[];
+    pagination: OffsetPagination;
+}
+/**
+ * Derived from the validity period. scheduled means valid_from has not yet arrived.
+ */
+export type FeatureGrantStatus = (typeof FeatureGrantStatus)[keyof typeof FeatureGrantStatus];
+export declare const FeatureGrantStatus: {
+    readonly scheduled: "scheduled";
+    readonly active: "active";
+    readonly expired: "expired";
+    readonly voided: "voided";
+};
+export interface FeatureGrant {
+    id: string;
+    billing_account_id: number;
+    product: Product;
+    feature: ObjectIdentity;
+    name: string;
+    valid_from: string;
+    /**
+     * Null means the grant does not expire.
+     * @nullable
+     */
+    valid_until: string | null;
+    status: FeatureGrantStatus;
+}
+export interface FeatureGrantList {
+    items: FeatureGrant[];
+    pagination: OffsetPagination;
+}
+export interface Entitlement {
+    product: Product;
+    feature: ObjectIdentity;
+    name?: string;
+    enabled: boolean;
+    /**
+     * When the providing subscription item ends with its current term. Absent for a metered item.
+     * @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;
+}
+/**
+ * How a ladder is walked: `graduated` charges each band at its own rate, `volume` charges everything at the rate of the band the total falls in. `none` when not tiered.
+ */
+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";
+};
+/**
+ * Licensed rates only, the period the amount buys; `none` for metered rates.
+ */
+export type RateInterval = (typeof RateInterval)[keyof typeof RateInterval];
+export declare const RateInterval: {
+    readonly none: "none";
+    readonly day: "day";
+    readonly month: "month";
+    readonly year: "year";
+};
+/**
+ * `graduated` charges each band at its own rate; `volume` charges everything at the rate of the band the total lands in. `none` for a `per_unit` rate.
+ */
+export type RateTiersMode = (typeof RateTiersMode)[keyof typeof RateTiersMode];
+export declare const RateTiersMode: {
+    readonly none: "none";
+    readonly graduated: "graduated";
+    readonly volume: "volume";
+};
+export interface Tier {
+    /**
+     * The band's inclusive upper bound; null for the last band.
+     * @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;
+}
+/**
+ * The dimension values this rate applies to, such as region and machine type.
+ */
+export type RateDimensions = {
+    [key: string]: string;
+};
+export interface Rate {
+    meter: ObjectIdentity;
+    /** The unit readings are reported in, such as `core-second`. */
+    unit?: string;
+    /** The dimension values this rate applies to, such as region and machine type. */
+    dimensions: RateDimensions;
+    billing_scheme: BillingScheme;
+    /** `metered` prices usage; `licensed` prices holding a quantity for one period. */
+    usage_type: UsageType;
+    /** Licensed rates only, the period the amount buys; `none` for metered rates. */
+    interval: RateInterval;
+    /** @nullable */
+    interval_count?: number | null;
+    /** `graduated` charges each band at its own rate; `volume` charges everything at the rate of the band the total lands in. `none` for a `per_unit` rate. */
+    tiers_mode: RateTiersMode;
+    /** Present for `per_unit`. Tiered rates carry their amounts on the tiers. */
+    unit_amount?: Money;
+    /** Present for a tiered rate, 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 Price {
+    /**
+     * For a price that delegates to a rate card, the rates in effect now that it charges at, one for each meter, dimension values and period; metered rates for a metered price, and rates on its own meter and period for a licensed one. `search-prices` narrows them with `dimensions`. Null for a price with its own amounts. Prices are set per currency, and dimension values a currency does not offer, for example in a region it does not sell to, have no rate in that currency and cannot be bought with it.
+     * @nullable
+     */
+    rates?: Rate[] | null;
+    lookup_key?: string;
+    product: Product;
+    plan: ObjectIdentity;
+    /** For a metered price with its own amounts, the meter it charges. For a licensed price, the meter its quantity is held on. Absent otherwise. */
+    meter_id?: string;
+    meter?: ObjectIdentity;
+    unit_quantity: string;
+    /** False once archived. An archived price cannot be bought until it is active again. */
+    active: boolean;
+    cancellation_policy?: CancellationPolicy;
+    refund_policy?: RefundPolicy;
+    /** Refund policy `short_rate` only, the factor applied to the value of the time used when a cancellation takes effect less than `short_rate_threshold_seconds` after the period start. */
+    short_rate_multiplier?: string;
+    /** Refund policy `short_rate` only, how long after the period start `short_rate_multiplier` applies. */
+    short_rate_threshold_seconds?: number;
+    product_id?: ProductId;
+    id: string;
+    plan_id: string;
+    currency: string;
+    type: PriceType;
+    usage_type: UsageType;
+    /** Absent when the price delegates to a rate card, where the rate depends on attributes such as region or machine type. */
+    billing_scheme?: BillingScheme;
+    /** Present for `per_unit`. */
+    unit_amount?: Money;
+    /** How a ladder is walked: `graduated` charges each band at its own rate, `volume` charges everything at the rate of the band the total falls in. `none` when not tiered. */
+    tiers_mode?: PriceTiersMode;
+    /** Present for `tiered`, in ascending order. */
+    tiers?: Tier[];
+    /** The smallest quantity that can be bought. Absent means no lower bound. */
+    min_quantity?: string;
+    /** The largest quantity that may be bought; absent when there is no limit. A larger quantity is refused 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 recurring licensed prices, how many interval units one period covers. */
+    interval_count?: number;
+    interval: PriceInterval;
+    setup_fee?: Money;
+}
+export interface PriceList {
+    items: Price[];
+    pagination: OffsetPagination;
+}
+/**
+ * The values of the meter's presentation dimensions, present only when grouped by meter.
+ */
+export type SpendRowDimensions = {
+    [key: string]: string;
+};
+export interface SpendRow {
+    product?: Product;
+    plan_id?: string;
+    plan_name?: string;
+    /** Present only when grouped by resource. */
+    resource_id?: string;
+    /** Present only when grouped by meter. */
+    meter?: ObjectIdentity;
+    /** Present only when grouped by meter. */
+    unit?: string;
+    /** Net usage quantity, present only when grouped by meter. */
+    quantity?: string;
+    /** The values of the meter's presentation dimensions, present only when grouped by meter. */
+    dimensions?: SpendRowDimensions;
+    amount: Money;
+    currency: string;
+}
+export interface SpendRowList {
+    items: SpendRow[];
+    /** The total over all matching groups, 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 closed: "closed";
+};
+/**
+ * A resource charged continuously by the second.
+ */
+export interface ActiveResource {
+    id: string;
+    ended_at?: string;
+    suspended_at?: string;
+    state_changed_at?: string;
+    /** The metered subscription item charged for this metering record. */
+    subscription_item_id: string;
+    /** The subscription the item belongs to. */
+    subscription_id: string;
+    resource_id: string;
+    product: Product;
+    /** The resource type, as the owning service names it. */
+    resource_type?: string;
+    meter: ObjectIdentity;
+    unit?: string;
+    /** How much is held, such as cores, MiB or cards; not how much was used. */
+    quantity: string;
+    dimensions?: ActiveResourceDimensions;
+    status: ActiveResourceStatus;
+    started_at: string;
+    project_id?: string;
+    /** Usage has been generated up to this boundary; it says nothing about invoicing or payment. */
+    usage_generated_until: string;
+}
+export interface ActiveResourceList {
+    items: ActiveResource[];
+    pagination: OffsetPagination;
+}
+/**
+ * An estimated refund to the original payment sources. Before acceptance, cancellation returns the collected amount. For delivered service, only value paid by this order is included; renewals are evaluated with their own orders under the agreed cancellation terms. Nothing is refunded by the preview; the amount is fixed when cancellation or termination is confirmed.
+ */
+export interface OrderRefundPreview {
+    order_id: string;
+    refundable_amount: Money;
+    refund_amount: Money;
+    credit_amount: Money;
+    currency: string;
+}
+/**
+ * The dimension values of the usage, such as region or token kind. Every key the meter declares must be given; a combination no rate covers is refused rather than priced at zero.
+ */
+export type UsageEstimateInputDimensions = {
+    [key: string]: string;
+};
+/**
+ * Future usage of one metered price. Give the price, or the plan to use its metered price in the currency, and the meter that measures the usage; give each resource's ID or lookup key, never both, and product_id with lookup keys.
+ */
+export interface UsageEstimateInput {
+    product_id?: ProductId;
+    plan_id?: string;
+    /**
+     * @minLength 1
+     * @maxLength 128
+     */
+    plan_lookup_key?: string;
+    price_id?: string;
+    /**
+     * @minLength 1
+     * @maxLength 128
+     */
+    price_lookup_key?: string;
+    meter_id?: string;
+    /**
+     * @minLength 1
+     * @maxLength 128
+     */
+    meter_lookup_key?: string;
+    /** The dimension values of the usage, such as region or token kind. Every key the meter declares must be given; a combination no rate covers is refused rather than priced at zero. */
+    dimensions?: UsageEstimateInputDimensions;
+    /**
+     * Decimal string. Positive.
+     * @pattern ^[0-9]{1,28}([.][0-9]{1,10})?$
+     */
+    quantity: string;
+    /**
+     * For a duration meter, how long the quantity is held; the priced quantity is `quantity` times this duration.
+     * @minimum 1
+     */
+    duration_seconds?: number;
+}
+export interface UsageEstimateRequest {
+    /**
+     * The ISO 4217 currency to price in.
+     * @minLength 3
+     * @maxLength 3
+     */
+    currency: string;
+    /**
+     * @minItems 1
+     * @maxItems 100
+     */
+    items: UsageEstimateInput[];
+}
+export interface UsageEstimateItem {
+    /**
+     * The zero-based request item this answers.
+     * @minimum 0
+     */
+    index: number;
+    price_id: string;
+    meter_id: string;
+    /** The quantity priced. */
+    quantity: string;
+    /** Null when the matched rates do not have a single unit price, for example a tiered rate. */
+    unit_amount: Money | null;
+    /**
+     * The quantity unit_amount is for; null with unit_amount.
+     * @nullable
+     */
+    unit_quantity: string | null;
+    /** Before discounts and tax, unrounded. */
+    amount: Money;
+}
+export interface UsageEstimate {
+    currency: string;
+    /** The sum of the items' amounts. */
+    amount: Money;
+    /** One per request item, in request order. */
+    items: UsageEstimateItem[];
+}
+/**
+ * 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;
+}
+export interface WithdrawalAllocation {
+    source_transaction_id: string;
+    /** @pattern ^[0-9]{1,15}([.][0-9]{1,10})?$ */
+    amount: string;
+    /** @pattern ^[0-9]{1,15}([.][0-9]{1,10})?$ */
+    fee_amount: string;
+    /** @pattern ^[0-9]{1,15}([.][0-9]{1,10})?$ */
+    refund_amount: string;
+}
+export type WithdrawalItemStatus = (typeof WithdrawalItemStatus)[keyof typeof WithdrawalItemStatus];
+export declare const WithdrawalItemStatus: {
+    readonly pending: "pending";
+    readonly succeeded: "succeeded";
+    readonly failed: "failed";
+    readonly reversed: "reversed";
+};
+/**
+ * The original top-up and where its refund goes. Card details are included when the original payment method was saved.
+ */
+export interface WithdrawalSource {
+    /** @pattern ^[0-9]{1,15}([.][0-9]{1,10})?$ */
+    amount: string;
+    /**
+     * @minLength 3
+     * @maxLength 3
+     */
+    currency: string;
+    received_at: string;
+    payment_gateway: string;
+    method_type: string;
+    card_brand?: string;
+    /** @pattern ^[0-9]{4}$ */
+    card_last4?: string;
+}
+/**
+ * For one original top-up: the principal deducted, the withdrawal fee and the amount refunded, through its own refund. payment_gateway and method_type identify the original route.
+ */
+export interface WithdrawalItem {
+    source_transaction_id: string;
+    /** @pattern ^[0-9]{1,15}([.][0-9]{1,10})?$ */
+    amount: string;
+    /** @pattern ^[0-9]{1,15}([.][0-9]{1,10})?$ */
+    fee_amount: string;
+    /** @pattern ^[0-9]{1,15}([.][0-9]{1,10})?$ */
+    refund_amount: string;
+    id: string;
+    withdrawal_id: string;
+    billing_account_id: number;
+    /**
+     * @minLength 3
+     * @maxLength 3
+     */
+    currency: string;
+    refund_id: string;
+    fee_transaction_id?: string;
+    status: WithdrawalItemStatus;
+    completed_at?: string;
+    payment_gateway: string;
+    method_type: string;
+    source: WithdrawalSource;
+    /** The gateway's failure code when a refund failed, or `refund_reversed` when a completed refund was reversed. Absent while pending or successful. */
+    failure_code?: string;
+}
+export type WithdrawalStatus = (typeof WithdrawalStatus)[keyof typeof WithdrawalStatus];
+export declare const WithdrawalStatus: {
+    readonly pending: "pending";
+    readonly processing: "processing";
+    readonly succeeded: "succeeded";
+    readonly partially_completed: "partially_completed";
+    readonly failed: "failed";
+    readonly reversed: "reversed";
+};
+/**
+ * A withdrawal of account balance to the original payment methods of its unused top-ups. Accepted amounts are fixed. deducted_amount, settled_amount and charged_fee_amount cover completed items. A failed item releases its principal and fee; successful items stand when another item fails.
+ */
+export interface Withdrawal {
+    id: string;
+    billing_account_id: number;
+    /**
+     * @minLength 3
+     * @maxLength 3
+     */
+    currency: string;
+    /** @pattern ^[0-9]{1,15}([.][0-9]{1,10})?$ */
+    amount: string;
+    /** @pattern ^[0-9]{1,15}([.][0-9]{1,10})?$ */
+    fee_amount: string;
+    /** @pattern ^[0-9]{1,15}([.][0-9]{1,10})?$ */
+    refund_amount: string;
+    /** @pattern ^[0-9]{1,15}([.][0-9]{1,10})?$ */
+    deducted_amount: string;
+    /** @pattern ^[0-9]{1,15}([.][0-9]{1,10})?$ */
+    settled_amount: string;
+    /** @pattern ^[0-9]{1,15}([.][0-9]{1,10})?$ */
+    charged_fee_amount: string;
+    status: WithdrawalStatus;
+    created_at: string;
+    completed_at?: string;
+    /** Who submitted the withdrawal; may differ from the account owner. */
+    created_by?: string;
+}
+export interface WithdrawalPreviewItem {
+    source_transaction_id: string;
+    /** @pattern ^[0-9]{1,15}([.][0-9]{1,10})?$ */
+    amount: string;
+    /** @pattern ^[0-9]{1,15}([.][0-9]{1,10})?$ */
+    fee_amount: string;
+    /** @pattern ^[0-9]{1,15}([.][0-9]{1,10})?$ */
+    refund_amount: string;
+    source: WithdrawalSource;
+}
+export interface WithdrawalPreview {
+    billing_account_id: number;
+    /**
+     * @minLength 3
+     * @maxLength 3
+     */
+    currency: string;
+    /** @pattern ^[0-9]{1,15}([.][0-9]{1,10})?$ */
+    available_amount: string;
+    /** @pattern ^[0-9]{1,15}([.][0-9]{1,10})?$ */
+    amount: string;
+    /** @pattern ^[0-9]{1,15}([.][0-9]{1,10})?$ */
+    fee_amount: string;
+    /** @pattern ^[0-9]{1,15}([.][0-9]{1,10})?$ */
+    refund_amount: string;
+    /** @maxItems 200 */
+    items: WithdrawalPreviewItem[];
+}
+export interface WithdrawalPreviewRequest {
+    billing_account_id: number;
+    /** @pattern ^[0-9]{1,15}([.][0-9]{1,10})?$ */
+    amount?: string;
+}
+export interface WithdrawalCreate {
+    id: string;
+    billing_account_id: number;
+    /** @pattern ^[0-9]{1,15}([.][0-9]{1,10})?$ */
+    amount: string;
+    /** @pattern ^[0-9]{1,15}([.][0-9]{1,10})?$ */
+    expected_refund_amount: string;
+    /**
+     * @minItems 1
+     * @maxItems 200
+     */
+    expected_items: WithdrawalAllocation[];
+}
+export interface WithdrawalList {
+    items: Withdrawal[];
+    pagination: OffsetPagination;
+}
+export interface WithdrawalItemList {
+    items: WithdrawalItem[];
+    pagination: OffsetPagination;
+}
+/**
+ * How tax applies to the customer, as in Stripe: `none` taxes normally, `exempt` charges no tax, `reverse` charges no tax under the reverse-charge mechanism, stated on invoices. Only operators change it.
+ */
+export type ContactTaxExempt = (typeof ContactTaxExempt)[keyof typeof ContactTaxExempt];
+export declare const ContactTaxExempt: {
+    readonly none: "none";
+    readonly exempt: "exempt";
+    readonly reverse: "reverse";
+};
+/**
+ * A contact of a billing account with one address. An account can hold several; a contact is not a login.
+ */
+export interface Contact {
+    id: string;
+    billing_account_id: number;
+    /**
+     * @minLength 1
+     * @maxLength 255
+     */
+    name: string;
+    /** @maxLength 255 */
+    legal_name?: string;
+    /** @maxLength 255 */
+    email?: string;
+    /** @maxLength 64 */
+    tax_id?: 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;
+    /** @pattern ^([A-Z]{2})?$ */
+    address_country?: string;
+    /** How tax applies to the customer, as in Stripe: `none` taxes normally, `exempt` charges no tax, `reverse` charges no tax under the reverse-charge mechanism, stated on invoices. Only operators change it. */
+    tax_exempt: ContactTaxExempt;
+    active: boolean;
+    created_at: string;
+}
+export interface ContactCreate {
+    /**
+     * @minLength 1
+     * @maxLength 255
+     */
+    name: string;
+    /** @maxLength 255 */
+    legal_name?: string;
+    /** @maxLength 255 */
+    email?: string;
+    /** @maxLength 64 */
+    tax_id?: 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;
+    /** @pattern ^([A-Z]{2})?$ */
+    address_country?: string;
+}
+export interface ContactUpdate {
+    /**
+     * @minLength 1
+     * @maxLength 255
+     */
+    name?: string;
+    /** @maxLength 255 */
+    legal_name?: string;
+    /** @maxLength 255 */
+    email?: string;
+    /** @maxLength 64 */
+    tax_id?: 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;
+    /** @pattern ^([A-Z]{2})?$ */
+    address_country?: string;
+    active?: boolean;
+}
+export interface ContactList {
+    items: Contact[];
+    pagination: OffsetPagination;
+}
+export type PriceSearchDimensionsItem = {
+    [key: string]: string;
+};
+/**
+ * Conditions combined with AND.
+ */
+export interface PriceSearch {
+    /**
+     * ISO 4217, three uppercase letters.
+     * @minLength 3
+     * @maxLength 3
+     */
+    currency: string;
+    /**
+     * Only these prices, such as the prices another service names.
+     * @minItems 1
+     * @maxItems 200
+     */
+    ids?: string[];
+    /**
+     * Only prices of these plans.
+     * @minItems 1
+     * @maxItems 200
+     */
+    plan_ids?: string[];
+    product_id?: ProductId;
+    /** Narrows to one price type. */
+    type?: PriceType;
+    /** Narrows to one usage type. */
+    usage_type?: UsageType;
+    /**
+     * Narrows each price's `rates` to these dimension value sets, given as on order lines and usage; prices are not filtered by it. A set no rate has adds nothing.
+     * @minItems 1
+     * @maxItems 200
+     */
+    dimensions?: PriceSearchDimensionsItem[];
+    /**
+     * 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 interface CancelSubscriptionRequest {
+    mode: CancellationMode;
+    /** For immediate cancellation, the preview's `proration_date`, the whole second the refund is computed as of. Now when omitted. */
+    proration_date?: string;
+    /** The preview's `refundable_amount`, including an explicit zero. */
+    expected_refundable_amount: Money & string;
+    /** @maxLength 1024 */
+    reason?: string;
+}
+export interface StatementAmounts {
+    subtotal: Money;
+    discount_amount: Money;
+    tax_amount: Money;
+    total: Money;
+    /** Added to total to round the invoiced amount to the currency's minor unit. Zero for an open statement's estimate. */
+    rounding_amount: Money;
+}
+/**
+ * One billing account's usage billing for one UTC calendar month, summed over its statements. Not payable itself; each statement's invoice is collected on its own.
+ */
+export interface MonthlyStatement {
+    billing_account_id: number;
+    currency: string;
+    period_start: string;
+    period_end: string;
+    /** True after the period's final closing, which applies the month's minimum charges. Usage priced later is billed in supplement statements and added here. */
+    finalized: boolean;
+    finalized_at?: string;
+    /** Statements of the period, including the open one. */
+    statement_count: number;
+    billed: StatementAmounts;
+    credited_amount: Money;
+    unbilled?: StatementAmounts;
+    credit_applied: Money;
+    amount_paid: Money;
+    amount_due: Money;
+    amount_refunded: Money;
+}
+export interface MonthlyStatementList {
+    items: MonthlyStatement[];
+    pagination: OffsetPagination;
+}
+export type StatementStatus = (typeof StatementStatus)[keyof typeof StatementStatus];
+export declare const StatementStatus: {
+    readonly open: "open";
+    readonly closed: "closed";
+};
+/**
+ * `interim`: a closing before the period's usage is final, without minimum charges. `final`: the first closing after the period ended and its late usage was settled, applying the period's minimum charges. `supplement`: a closing after the final one, for usage priced late. An open statement is interim.
+ */
+export type StatementType = (typeof StatementType)[keyof typeof StatementType];
+export declare const StatementType: {
+    readonly interim: "interim";
+    readonly final: "final";
+    readonly supplement: "supplement";
+};
+/**
+ * An account's consumption for one billing period up to one closing. Usage is invoiced after every settlement run, about hourly: each closing issues an invoice for the usage priced since the previous one and collects it from credits and balance, and later usage goes into the next statement of the same period. A closed statement does not change. The period's consumption is the sum of its statements.
+ */
+export interface Statement {
+    id: string;
+    billing_account_id: number;
+    currency: string;
+    period_start: string;
+    period_end: string;
+    /** Increases with each closing of the period. */
+    sequence: number;
+    status: StatementStatus;
+    type: StatementType;
+    /** True while the statement is open. The estimate prices the period's usage so far at tier prices and adds tax for the current invoice contact. Minimum charges are added at the period's final closing, and a tier reduction larger than this statement's charges is credited to the period's earlier invoices at closing. */
+    estimated: boolean;
+    amounts: StatementAmounts;
+    closed_at?: string;
+    /** The invoice issued at this closing, when it produced one. */
+    invoice_id?: string;
+    created_at: string;
+    calculated_at?: string;
+    credited_amount: Money;
+}
+export interface StatementList {
+    items: Statement[];
+    pagination: OffsetPagination;
+}
+/**
+ * The values of the meter's presentation dimensions, such as the model and token kind. Included only when grouping by meter, which splits each meter by these values.
+ */
+export type StatementItemDimensions = {
+    [key: string]: string;
+};
+export interface StatementItem {
+    project_id?: string;
+    product_id?: string;
+    meter_id?: string;
+    unit?: string;
+    /** The values of the meter's presentation dimensions, such as the model and token kind. Included only when grouping by meter, which splits each meter by these values. */
+    dimensions?: StatementItemDimensions;
+    /** Net usage quantity. Included only when grouping by meter. */
+    quantity?: string;
+    deducted_quantity?: string;
+    amount: Money;
+}
+export type StatementSummaryGroupBy = (typeof StatementSummaryGroupBy)[keyof typeof StatementSummaryGroupBy];
+export declare const StatementSummaryGroupBy: {
+    readonly project: "project";
+    readonly product: "product";
+    readonly meter: "meter";
+};
+export interface StatementSummary {
+    statement_id: string;
+    currency: string;
+    estimated: boolean;
+    calculated_at?: string;
+    group_by: StatementSummaryGroupBy;
+    items: StatementItem[];
+    pagination: OffsetPagination;
+}
+/**
+ * Error
+ */
+export type ErrorResponse = Error;
+/**
+ * Unchanged since the given `ETag`; no body.
+ */
+export type NotModifiedResponse = void;
+export type FromParameter = string;
+/**
+ * Exclusive.
+ */
+export type ToParameter = string;
+/**
+ * Only this account; all of yours when omitted.
+ */
+export type AccountIdQueryParameter = number;
+/**
+ * The `ETag` of an earlier response. When the catalogue has not changed since, the response is `304` with no body.
+ */
+export type IfNoneMatchParameter = string;
+export type FromRequiredParameter = string;
+/**
+ * Exclusive. One month is `[2026-09-01, 2026-10-01)`.
+ */
+export type ToRequiredParameter = string;
+/**
+ * Only records of these projects. Omit for all projects and account-level records of your billing accounts. Where an operation is open to project members, each project must be assigned to a billing account you own or have you as a member, and a member sees the records of the project that the owner of its current billing account sees.
+ */
+export type ProjectIdsQueryParameter = string[];
+export type ListWithdrawalItemsParams = {
+    /**
+     * 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 ListWithdrawalsParams = {
+    /**
+     * 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;
+    /**
+     * Only withdrawals in these statuses; omit for every status. Comma-separated, for example `status=pending,processing`.
+     * @minItems 1
+     * @maxItems 6
+     */
+    status?: WithdrawalStatus[];
+};
+export type ListContactsParams = {
+    /**
+     * 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 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;
+    /**
+     * Only accounts in these statuses. Omit for all statuses. Comma-separated, for example `status=suspended,closed`.
+     * @minItems 1
+     * @maxItems 3
+     */
+    status?: BillingAccountStatus[];
+};
+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;
+    /**
+     * Only records of these projects. Omit for all projects and account-level records of your billing accounts. Where an operation is open to project members, each project must be assigned to a billing account you own or have you as a member, and a member sees the records of the project that the owner of its current billing account sees.
+     * @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;
+    /**
+     * Only this account; all of yours when omitted.
+     */
+    billing_account_id?: AccountIdQueryParameter;
+    /**
+     * Only top-ups in these statuses; omit for every status. Comma-separated, for example `status=pending,succeeded`.
+     * @minItems 1
+     * @maxItems 4
+     */
+    status?: TopUpStatus[];
+};
+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;
+    /**
+     * Only this account; all of yours when omitted.
+     */
+    billing_account_id?: AccountIdQueryParameter;
+    /**
+     * Only payment methods in these statuses; omit for both. Removed payment methods are not listed. Comma-separated.
+     * @minItems 1
+     * @maxItems 2
+     */
+    status?: ListPaymentMethodsStatusItem[];
+};
+export type ListPaymentMethodsStatusItem = (typeof ListPaymentMethodsStatusItem)[keyof typeof ListPaymentMethodsStatusItem];
+export declare const ListPaymentMethodsStatusItem: {
+    readonly active: "active";
+    readonly expired: "expired";
+};
+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;
+    /**
+     * Only this account; all of yours when omitted.
+     */
+    billing_account_id?: AccountIdQueryParameter;
+    /**
+     * Only invoices in these statuses; omit for every status. Comma-separated, for example `status=open,paid`.
+     * @minItems 1
+     * @maxItems 3
+     */
+    status?: InvoiceStatus[];
+    /**
+     * Only invoices with a charge from this subscription; amounts are for the whole invoice.
+     */
+    subscription_id?: string;
+    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;
+    /**
+     * Only this account; all of yours when omitted.
+     */
+    billing_account_id?: AccountIdQueryParameter;
+    from?: FromParameter;
+    /**
+     * Exclusive.
+     */
+    to?: ToParameter;
+    /**
+     * Only transactions of these types; omit for every type. Comma-separated, for example `type=topup,refund`.
+     * @minItems 1
+     * @maxItems 5
+     */
+    type?: TransactionType[];
+    /**
+     * Only transactions in these statuses; omit for every status. Comma-separated, for example `status=pending,failed`.
+     * @minItems 1
+     * @maxItems 4
+     */
+    status?: TransactionStatus[];
+};
+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;
+    /**
+     * Only this account; all of yours when omitted.
+     */
+    billing_account_id?: AccountIdQueryParameter;
+    /**
+     * Only discounts in these statuses; omit for every status. Comma-separated, for example `status=scheduled,active`.
+     * @minItems 1
+     * @maxItems 4
+     */
+    status?: DiscountStatus[];
+};
+export type ListTrialGrantsParams = {
+    /**
+     * 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;
+    /**
+     * Only this account; all of yours when omitted.
+     */
+    billing_account_id?: AccountIdQueryParameter;
+    /**
+     * Only grants in these statuses; omit for every status. Comma-separated, for example `status=available,scheduled`.
+     * @minItems 1
+     * @maxItems 5
+     */
+    status?: TrialGrantStatus[];
+};
+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;
+    /**
+     * Only this account; all of yours when omitted.
+     */
+    billing_account_id?: AccountIdQueryParameter;
+    /**
+     * Only credit grants in these statuses; omit for every status. Comma-separated, for example `status=active,depleted`.
+     * @minItems 1
+     * @maxItems 4
+     */
+    status?: CreditGrantStatus[];
+};
+export type ListCreditNotesParams = {
+    /**
+     * 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;
+    /**
+     * Only this account; all of yours when omitted.
+     */
+    billing_account_id?: AccountIdQueryParameter;
+    /**
+     * Only the notes for this invoice.
+     */
+    invoice_id?: string;
+    /**
+     * Only credit notes in these statuses; omit for both. Comma-separated.
+     * @minItems 1
+     * @maxItems 2
+     */
+    status?: CreditNoteStatus[];
+};
+export type ListCreditNoteItemsParams = {
+    /**
+     * 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 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;
+    /**
+     * Only this account; all of yours when omitted.
+     */
+    billing_account_id?: AccountIdQueryParameter;
+    /**
+     * Only the refunds of this invoice.
+     */
+    invoice_id?: string;
+    /**
+     * Refunds of this order: those of its invoice, such as for an undeliverable purchase, and those it caused on an earlier invoice, such as a downgrade difference.
+     */
+    order_id?: string;
+    /**
+     * Only refunds in these statuses; omit for every status. Comma-separated, for example `status=pending,processing`.
+     * @minItems 1
+     * @maxItems 4
+     */
+    status?: RefundStatus[];
+};
+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;
+    /**
+     * Only this account; all of yours 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;
+    /**
+     * Only records of these projects. Omit for all projects and account-level records of your billing accounts. Where an operation is open to project members, each project must be assigned to a billing account you own or have you as a member, and a member sees the records of the project that the owner of its current billing account sees.
+     * @minItems 1
+     * @maxItems 100
+     */
+    project_ids?: ProjectIdsQueryParameter;
+    meter_id?: string;
+    statement_id?: string;
+};
+export type ListSubscriptionsParams = {
+    expiring_before?: string;
+    /**
+     * Only these subscriptions, such as those of the resources shown on one page. Comma-separated.
+     * @minItems 1
+     * @maxItems 200
+     */
+    subscription_ids?: 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;
+    /**
+     * Only this account; all of yours when omitted.
+     */
+    billing_account_id?: AccountIdQueryParameter;
+    /**
+     * Only records of these projects. Omit for all projects and account-level records of your billing accounts. Where an operation is open to project members, each project must be assigned to a billing account you own or have you as a member, and a member sees the records of the project that the owner of its current billing account sees.
+     * @minItems 1
+     * @maxItems 100
+     */
+    project_ids?: ProjectIdsQueryParameter;
+    /**
+     * Only subscriptions in these statuses; omit for every status. Comma-separated, for example `status=active,suspended`.
+     * @minItems 1
+     * @maxItems 7
+     */
+    status?: SubscriptionStatus[];
+};
+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;
+    /**
+     * Only this account; all of yours when omitted.
+     */
+    billing_account_id?: AccountIdQueryParameter;
+    /**
+     * Only cancellations that include an item of this subscription.
+     */
+    subscription_id?: string;
+    /**
+     * Only cancellations that include this subscription item.
+     */
+    subscription_item_id?: string;
+    /**
+     * Only cancellations in these statuses; omit for every status. `open` means requested, scheduled or releasing. Comma-separated, for example `status=open,failed`.
+     * @minItems 1
+     * @maxItems 7
+     */
+    status?: ListCancellationsStatusItem[];
+    /**
+     * Only records of these projects. Omit for all projects and account-level records of your billing accounts. Where an operation is open to project members, each project must be assigned to a billing account you own or have you as a member, and a member sees the records of the project that the owner of its current billing account sees.
+     * @minItems 1
+     * @maxItems 100
+     */
+    project_ids?: ProjectIdsQueryParameter;
+};
+export type ListCancellationsStatusItem = (typeof ListCancellationsStatusItem)[keyof typeof ListCancellationsStatusItem];
+export declare const ListCancellationsStatusItem: {
+    readonly open: "open";
+    readonly requested: "requested";
+    readonly scheduled: "scheduled";
+    readonly releasing: "releasing";
+    readonly completed: "completed";
+    readonly canceled: "canceled";
+    readonly failed: "failed";
+};
+export type ListRenewalOptionsParams = {
+    /**
+     * 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;
+    /**
+     * Only this account; all of yours when omitted.
+     */
+    billing_account_id?: AccountIdQueryParameter;
+    /**
+     * Filter by the meter UUID.
+     */
+    meter_id?: string;
+    /**
+     * Only allowances in these statuses; omit for every status. Comma-separated, for example `status=active,depleted`.
+     * @minItems 1
+     * @maxItems 4
+     */
+    status?: AllowanceStatus[];
+    product_id?: ProductId;
+    /**
+     * Only records of these projects. Omit for all projects and account-level records of your billing accounts. Where an operation is open to project members, each project must be assigned to a billing account you own or have you as a member, and a member sees the records of the project that the owner of its current billing account sees.
+     * @minItems 1
+     * @maxItems 100
+     */
+    project_ids?: ProjectIdsQueryParameter;
+};
+export type ListCheckoutSessionsParams = {
+    /**
+     * 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;
+    /**
+     * Only this account; all of yours when omitted.
+     */
+    billing_account_id?: AccountIdQueryParameter;
+    /**
+     * Only sessions in these statuses; omit for every status. Comma-separated, for example `status=open,expired`.
+     * @minItems 1
+     * @maxItems 3
+     */
+    status?: CheckoutSessionStatus[];
+    /**
+     * Only records of these projects. Omit for all projects and account-level records of your billing accounts. Where an operation is open to project members, each project must be assigned to a billing account you own or have you as a member, and a member sees the records of the project that the owner of its current billing account sees.
+     * @minItems 1
+     * @maxItems 100
+     */
+    project_ids?: ProjectIdsQueryParameter;
+};
+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;
+    /**
+     * Only this account; all of yours when omitted.
+     */
+    billing_account_id?: AccountIdQueryParameter;
+    /**
+     * Only orders in these statuses; omit for every status. Comma-separated, for example `status=pending,accepted`.
+     * @minItems 1
+     * @maxItems 6
+     */
+    status?: OrderStatus[];
+    from?: FromParameter;
+    /**
+     * Exclusive.
+     */
+    to?: ToParameter;
+    /**
+     * Only records of these projects. Omit for all projects and account-level records of your billing accounts. Where an operation is open to project members, each project must be assigned to a billing account you own or have you as a member, and a member sees the records of the project that the owner of its current billing account sees.
+     * @minItems 1
+     * @maxItems 100
+     */
+    project_ids?: ProjectIdsQueryParameter;
+};
+export type PreviewOrderRefundParams = {
+    /**
+     * Only these items of the order. Omit for the whole order.
+     * @minItems 1
+     * @maxItems 100
+     */
+    order_item_ids?: string[];
+};
+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;
+    /**
+     * Only this account; all of yours when omitted.
+     */
+    billing_account_id?: AccountIdQueryParameter;
+    /**
+     * Only records of these projects. Omit for all projects and account-level records of your billing accounts. Where an operation is open to project members, each project must be assigned to a billing account you own or have you as a member, and a member sees the records of the project that the owner of its current billing account sees.
+     * @minItems 1
+     * @maxItems 100
+     */
+    project_ids?: ProjectIdsQueryParameter;
+    product_id?: ProductId;
+};
+export type ListFeatureGrantsParams = {
+    /**
+     * 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;
+    /**
+     * Only this account; all of yours when omitted.
+     */
+    billing_account_id?: AccountIdQueryParameter;
+    product_id?: ProductId;
+    /**
+     * Only feature grants in these statuses; omit for every status. Comma-separated, for example `status=scheduled,active`.
+     * @minItems 1
+     * @maxItems 4
+     */
+    status?: FeatureGrantStatus[];
+};
+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 price type.
+     */
+    type?: PriceType;
+    /**
+     * Narrows to one usage type.
+     */
+    usage_type?: UsageType;
+};
+export type ListPricesHeaders = {
+    /**
+     * The `ETag` of an earlier response. When the catalogue has not changed since, the response is `304` with no 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` of an earlier response. When the catalogue has not changed since, the response is `304` with no body.
+     */
+    "If-None-Match"?: IfNoneMatchParameter;
+};
+export type GetProductHeaders = {
+    /**
+     * The `ETag` of an earlier response. When the catalogue has not changed since, the response is `304` with no body.
+     */
+    "If-None-Match"?: IfNoneMatchParameter;
+};
+export type GetPlanHeaders = {
+    /**
+     * The `ETag` of an earlier response. When the catalogue has not changed since, the response is `304` with no body.
+     */
+    "If-None-Match"?: IfNoneMatchParameter;
+};
+export type GetPriceHeaders = {
+    /**
+     * The `ETag` of an earlier response. When the catalogue has not changed since, the response is `304` with no 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` of an earlier response. When the catalogue has not changed since, the response is `304` with no 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;
+    /**
+     * Narrows to one price type.
+     */
+    type?: PriceType;
+    /**
+     * Narrows to one usage type.
+     */
+    usage_type?: UsageType;
+};
+export type ListPricesByPlanHeaders = {
+    /**
+     * The `ETag` of an earlier response. When the catalogue has not changed since, the response is `304` with no 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;
+    /**
+     * Only this account; all of yours when omitted.
+     */
+    billing_account_id?: AccountIdQueryParameter;
+    /**
+     * Only records of these projects. Omit for all projects and account-level records of your billing accounts. Where an operation is open to project members, each project must be assigned to a billing account you own or have you as a member, and a member sees the records of the project that the owner of its current billing account sees.
+     * @minItems 1
+     * @maxItems 100
+     */
+    project_ids?: ProjectIdsQueryParameter;
+    meter_id?: string;
+    product_id?: ProductId;
+    /**
+     * Only metering in these statuses; omit for every status. Comma-separated, for example `status=active,suspended`.
+     * @minItems 1
+     * @maxItems 4
+     */
+    status?: ActiveResourceStatus[];
+};
+export type ListSpendParams = {
+    from: FromRequiredParameter;
+    /**
+     * Exclusive. One month is `[2026-09-01, 2026-10-01)`.
+     */
+    to: ToRequiredParameter;
+    /**
+     * `plan` groups by the plan of the price each charge was priced with, unchanged after the subscription changes plan. `resource` groups by the resource each charge names; a disk or an address billed under its own identifier is its own row. `meter` groups by meter and the values of its presentation dimensions, such as the model and token kind, and includes the quantity used.
+     */
+    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 billing account whose currency and charges the report uses; it must be authorized.
+     */
+    billing_account_id: number;
+    /**
+     * Only records of these projects. Omit for all projects and account-level records of your billing accounts. Where an operation is open to project members, each project must be assigned to a billing account you own or have you as a member, and a member sees the records of the project that the owner of its current billing account sees.
+     * @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";
+    readonly meter: "meter";
+};
+export type ListMonthlyStatementsParams = {
+    billing_account_id?: number;
+    /**
+     * Earliest period start, inclusive.
+     */
+    from?: string;
+    /**
+     * Latest period start, exclusive.
+     */
+    to?: 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;
+};
+export type ListStatementsParams = {
+    billing_account_id?: number;
+    /**
+     * Only statements in these statuses; omit for every status. Comma-separated.
+     * @minItems 1
+     * @maxItems 2
+     */
+    status?: StatementStatus[];
+    from?: string;
+    to?: 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;
+};
+export type GetStatementUsageParams = {
+    group_by?: GetStatementUsageGroupBy;
+    /**
+     * @maxItems 100
+     */
+    project_ids?: string[];
+    /**
+     * @maxLength 64
+     */
+    product_id?: string;
+    meter_id?: 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;
+};
+export type GetStatementUsageGroupBy = (typeof GetStatementUsageGroupBy)[keyof typeof GetStatementUsageGroupBy];
+export declare const GetStatementUsageGroupBy: {
+    readonly project: "project";
+    readonly product: "product";
+    readonly meter: "meter";
+};