@leaflow/sdk 0.0.0-dev.35.g30ba751 → 0.0.0-dev.353.g74313e0

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

@@ -0,0 +1,3689 @@
+/**
+ * Generated by orval 🍺
+ * Do not edit manually.
+ * Leaflow Billing API
+ * Products, prices, orders, subscriptions and account billing. Financial operations require an account access token and billing-account authorization. Public catalogue operations declare no security requirement.
+ * OpenAPI spec version: v1
+ */
+/**
+ * Whether a delivered purchase may end immediately or only at the end of its paid term; refunds follow the refund policy. When absent, no termination terms were agreed.
+ */
+export type TerminationPolicy = (typeof TerminationPolicy)[keyof typeof TerminationPolicy];
+export declare const TerminationPolicy: {
+    readonly immediate: "immediate";
+    readonly period_end: "period_end";
+};
+/**
+ * `none` refunds nothing. `prorated` refunds the amount paid for the current period minus the value of the time used, never below zero or above what remains unrefunded. Time used runs from the period start to the effective cancellation and is valued at prices frozen on the order item: each full calendar month at `refund_monthly_amount`, the rest at `refund_hourly_amount` or, without it, at the monthly price by the second. When the plan has no licensed period shorter than the one bought, time used is valued pro rata at the price paid. Discounts and setup fees are not refunded. Refunds return to the original payment sources, with tax refunded in proportion.
+ */
+export type RefundPolicy = (typeof RefundPolicy)[keyof typeof RefundPolicy];
+export declare const RefundPolicy: {
+    readonly none: "none";
+    readonly prorated: "prorated";
+};
+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[];
+}
+export type QuoteRenewalInterval = (typeof QuoteRenewalInterval)[keyof typeof QuoteRenewalInterval];
+export declare const QuoteRenewalInterval: {
+    readonly day: "day";
+    readonly month: "month";
+    readonly year: "year";
+};
+/**
+ * Price renewing a licensed subscription. Give `price_id`, or `interval` with
+ * `interval_count`, to renew for another term at the price currently sold for it. Naming
+ * the current term, or giving neither, renews at the agreed amount. A term sold at several
+ * prices that differ in termination policy is refused with 409
+ * `BILLING_RENEWAL_OPTION_AMBIGUOUS` unless `termination_policy` or `price_id` is given.
+ */
+export interface QuoteRenewal {
+    subscription_id: string;
+    price_id?: string;
+    interval?: QuoteRenewalInterval;
+    /** @minimum 1 */
+    interval_count?: number;
+    /** With `interval` and `interval_count`, chooses among prices of that term that differ in termination policy. */
+    termination_policy?: TerminationPolicy;
+    /**
+     * How many consecutive periods to renew for.
+     * @minimum 1
+     * @maximum 100
+     */
+    periods?: number;
+}
+export type QuoteRenewalResultInterval = (typeof QuoteRenewalResultInterval)[keyof typeof QuoteRenewalResultInterval];
+export declare const QuoteRenewalResultInterval: {
+    readonly day: "day";
+    readonly month: "month";
+    readonly year: "year";
+};
+/**
+ * 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;
+/**
+ * What renewing would charge. Renewing the same subscription for the same term and periods charges exactly `total` unless prices or the account's discounts change first.
+ */
+export interface QuoteRenewalResult {
+    /** Which renewal of the request this answers. */
+    index: number;
+    subscription_id: string;
+    /** The price the renewal is charged under. */
+    price_id: string;
+    interval: QuoteRenewalResultInterval;
+    interval_count: number;
+    periods: number;
+    /** The price of the periods before the account's discounts, with any discount the subscription carries already reflected; includes tax only where the price does. */
+    amount: Money;
+    /** The reduction from a discount the account holds. */
+    discount_amount: Money;
+    /** Tax on the discounted amount. */
+    tax_amount: Money;
+    /** The part of `tax_amount` already contained in `amount`. */
+    tax_included_amount: Money;
+    /**
+     * What renewing would charge: `amount` less `discount_amount`, plus `tax_amount`, less
+     * `tax_included_amount`.
+     */
+    total: Money;
+}
+/**
+ * One fully calculated purchase, estimated metered usage or recorded order item. Amounts use the
+ * billing-account currency. An item with no immediate charge has zero checkout amounts.
+ */
+export interface QuoteItem {
+    tax_amount: Money;
+    tax_included_amount: Money;
+    /**
+     * The zero-based request line index, or the recorded order item's position for an order quote.
+     * @minimum 0
+     */
+    index: number;
+    /** Present for an existing order quote; identifies the recorded item being priced. */
+    order_item_id?: string;
+    /** The selected price, also when the request identified it indirectly. */
+    price_id: string;
+    plan_name: string;
+    /** Unit price before discounts. Null when no single unit price applies, such as tiered or multiple-rate pricing. */
+    unit_amount: Money | null;
+    /** The quantity priced; with duration_seconds, quantity times the duration. */
+    quantity: string;
+    /** Amount before discounts and including any setup charge. For requested future usage this is an estimate, not a collectible checkout amount. */
+    amount: Money;
+    discount_amount: Money;
+    total: Money;
+    currency: string;
+}
+/**
+ * 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 quoted purchases or metered usage. Each grant is counted once. */
+    usable_credit_amount: Money;
+    /** Currently effective credits that cannot fund any quoted purchase 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 quote. 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;
+}
+export type QuotedDiscountType = (typeof QuotedDiscountType)[keyof typeof QuotedDiscountType];
+export declare const QuotedDiscountType: {
+    readonly promotion_code: "promotion_code";
+    readonly account_discount: "account_discount";
+};
+/**
+ * The discount selected for this calculation, not applied and not reserved. Amounts are on the quote and its lines.
+ */
+export interface QuotedDiscount {
+    type: QuotedDiscountType;
+    name: string;
+    /**
+     * Code text for a promotion_code discount; null for an account_discount.
+     * @minLength 1
+     * @maxLength 64
+     * @nullable
+     */
+    promotion_code: string | null;
+}
+/**
+ * Which object this is, together with what a person currently calls it.
+ *
+ * The name is for display. It is chosen by whoever owns the object, it changes, it is not unique
+ * between objects, and it may be empty when nobody has named it yet — so it must not be used to
+ * address, match or deduplicate anything. Addressing is by id.
+ *
+ * This differs from an identity carrying a lookup key: a lookup key is written once by an operator,
+ * is unique, and can be used to fetch the object. A name cannot.
+ */
+export interface NamedIdentity {
+    id: string;
+    /** @maxLength 255 */
+    name: string;
+}
+/**
+ * `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 of the quoted cancellation.
+ */
+export interface CancellationRefundPreviewItem {
+    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 automatic renewal is on now. Creating the cancellation turns it off; withdrawing it turns it back on for a metered subscription but not for a licensed one. */
+    auto_renew: boolean;
+    unused_amount: Money;
+    refundable_amount: Money;
+    refund_amount: Money;
+    credit_amount: Money;
+    tax_amount: Money;
+    forfeited_amount: Money;
+}
+/**
+ * What the cancellation would return, per subscription and in total, as of now. Give `proration_date` and
+ * `refundable_amount` when creating the cancellation.
+ *
+ * - `unused_amount`: before tax, the amount paid for the current periods minus the value of the time used,
+ *   valued as refund policy `prorated` describes, whatever the refund terms say.
+ * - `refundable_amount`: what is returned the way it was paid, 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 subscriptions show zero; their usage until release is charged as usual.
+ */
+export interface CancellationRefundPreview {
+    mode: TerminationPolicy;
+    /** For `period_end`, when release begins, the end of the paid terms. */
+    scheduled_at?: string;
+    /** For `immediate`, the second the refund is computed as of. Give it when creating the cancellation. */
+    proration_date?: string;
+    currency: string;
+    unused_amount: Money;
+    refundable_amount: Money;
+    refund_amount: Money;
+    credit_amount: Money;
+    tax_amount: Money;
+    forfeited_amount: Money;
+    items: CancellationRefundPreviewItem[];
+}
+/**
+ * An estimated refund to 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 termination terms. Nothing is refunded by the quote; the amount is fixed when cancellation or termination is confirmed.
+ */
+export interface OrderRefundQuote {
+    order_id: string;
+    refundable_amount: Money;
+    refund_amount: Money;
+    credit_amount: Money;
+    currency: string;
+}
+/**
+ * A complete calculation in the billing account's currency; nothing is saved or reserved. The request fails if any item cannot be priced. Usage estimates are included in totals but are not collected at checkout; only an existing-order quote gives that order's checkout amount.
+ */
+export interface Quote {
+    /** Account funds for an existing-order checkout quote. Absent for usage estimates, refunds and cancellations. */
+    funds?: Funds;
+    subtotal: Money;
+    discount_amount: Money;
+    tax_amount: Money;
+    /** The discount a purchase or order would get, not yet applied. Null when there is none, and for renewals and cancellations. A confirmed order reports its recorded discount. */
+    discount: QuotedDiscount | null;
+    items: QuoteItem[];
+    renewals: QuoteRenewalResult[];
+    /** What the cancellation requested would return. Present only when one was requested. */
+    cancellation?: CancellationRefundPreview;
+    total: Money;
+    currency: string;
+    /** Present when an order refund was requested. */
+    refund?: OrderRefundQuote;
+}
+/**
+ * A cancellation to quote: what ending these subscriptions together would return, for one mode; quote `immediate` and `period_end` separately to compare. Refused with 409 `BILLING_SUBSCRIPTION_OPERATION_PENDING` when a subscription is already being canceled (`meta.cancellation_id`), is being reclaimed (`meta.reason` `reclaim_requested`) or has a paid change waiting to switch (`meta.order_id`).
+ */
+export interface QuoteCancellation {
+    /**
+     * The subscriptions to end together, all of one service, including every subscription released with a resource.
+     * @minItems 1
+     * @maxItems 50
+     */
+    subscription_ids: string[];
+    mode: TerminationPolicy;
+}
+export interface CancellationCreate {
+    /**
+     * As in the quote.
+     * @minItems 1
+     * @maxItems 50
+     */
+    subscription_ids: string[];
+    mode: TerminationPolicy;
+    /** For `immediate`, the quote'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 quote'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 of the cancellation.
+ */
+export interface CancellationItem {
+    /** The subscription's cancellation item, the same as `Subscription.cancellation.id`. */
+    id: string;
+    subscription_id: string;
+    plan_id: string;
+    plan_name: string;
+    type: PriceType;
+    /**
+     * Creating the cancellation turned automatic renewal off; withdrawing it turns renewal back on
+     * for a `metered` subscription and leaves it off for a `licensed` one.
+     */
+    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 subscriptions of one service, released together at one time.
+ *
+ * - `requested`: `immediate`, release has not begun.
+ * - `scheduled`: `period_end`, waiting for `scheduled_at`.
+ * - `releasing`: release has begun; it can no longer be withdrawn.
+ * - `completed`: every subscription has ended and its refund has been made.
+ * - `canceled`: withdrawn before release began; the subscriptions continue.
+ * - `failed`: the service could not carry it out, for the reason in `failure_code`; the
+ *   subscriptions continue and can be canceled again.
+ */
+export interface Cancellation {
+    id: string;
+    status: CancellationStatus;
+    mode: TerminationPolicy;
+    scheduled_at?: string;
+    /** For `immediate`, the second the refund is computed as of. */
+    proration_date?: string;
+    /** Who requested it; `project_deletion` means the project was deleted. */
+    origin: CancellationOrigin;
+    /** The billing account paying for these subscriptions 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 SubscriptionCancellationStatus = (typeof SubscriptionCancellationStatus)[keyof typeof SubscriptionCancellationStatus];
+export declare const SubscriptionCancellationStatus: {
+    readonly requested: "requested";
+    readonly scheduled: "scheduled";
+    readonly releasing: "releasing";
+    readonly failed: "failed";
+    readonly completed: "completed";
+    readonly canceled: "canceled";
+};
+export type SubscriptionCancellationMode = (typeof SubscriptionCancellationMode)[keyof typeof SubscriptionCancellationMode];
+export declare const SubscriptionCancellationMode: {
+    readonly immediate: "immediate";
+    readonly period_end: "period_end";
+};
+/**
+ * The latest cancellation including the subscription, with this subscription's item: `id` is the item and `cancellation_id` the cancellation. scheduled_at is the intended time and effective_at the confirmed end of service.
+ */
+export interface SubscriptionCancellation {
+    reason?: string;
+    /** The cancellation this item belongs to, with the other subscriptions released together. */
+    cancellation_id?: string;
+    id: string;
+    subscription_id: string;
+    status: SubscriptionCancellationStatus;
+    mode: SubscriptionCancellationMode;
+    requested_at: string;
+    scheduled_at?: string;
+    effective_at?: string;
+    completed_at?: string;
+    release_started_at?: string;
+    canceled_at?: string;
+    forfeit_remaining_value: boolean;
+    failure_code?: string;
+    failure_reason?: string;
+}
+/**
+ * What a given `code` carries alongside the message. The keys depend on the code,
+ * and a client that does not recognise one ignores it.
+ */
+export type ErrorMeta = {
+    [key: string]: unknown;
+};
+export interface Error {
+    code?: string;
+    message: string;
+    /**
+     * What a given `code` carries alongside the message. The keys depend on the code,
+     * and a client that does not recognise one ignores it.
+     */
+    meta?: ErrorMeta;
+    status: number;
+}
+/**
+ * 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;
+}
+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;
+    /** 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;
+}
+/**
+ * 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;
+}
+/**
+ * `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";
+};
+export interface AccountIdentity {
+    id: number;
+    name: string;
+    currency: string;
+}
+/**
+ * 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;
+    /** `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. */
+    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;
+    /**
+     * The code to apply while the order's terms are not fixed. Omit to apply the best applicable account discount, or to keep the discount already recorded.
+     * @minLength 1
+     * @maxLength 64
+     */
+    promotion_code?: string;
+    /** The invoice total to expect, after discounts and tax and before credit grants or balance, as the payment preview or an order quote gave it. A different total fails with `BILLING_AMOUNT_CHANGED` and nothing is charged. Omit to skip the check; zero is checked. */
+    expected_amount?: Money & 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;
+}
+/**
+ * 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;
+    /** `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. */
+    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;
+}
+/**
+ * `draft`: not yet issued; an order's draft invoice shows base prices until it is paid, when the discount is applied and it is issued. Other drafts are visible only to operators. `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 draft: "draft";
+    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; they do not reduce it. */
+    total: 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 after unpaid credit notes and successful payments; never below zero. Zero for a draft, whose total is the base price, and 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;
+}
+export type InvoiceItemType = (typeof InvoiceItemType)[keyof typeof InvoiceItemType];
+export declare const InvoiceItemType: {
+    readonly usage: "usage";
+    readonly subscription: "subscription";
+    readonly one_time: "one_time";
+    readonly setup: "setup";
+    readonly adjustment: "adjustment";
+};
+/**
+ * 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.
+ */
+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;
+    type?: InvoiceItemType;
+    /** @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;
+    amount: Money;
+    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 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;
+}
+export type CreditNoteStatus = (typeof CreditNoteStatus)[keyof typeof CreditNoteStatus];
+export declare const CreditNoteStatus: {
+    readonly issued: "issued";
+    readonly void: "void";
+};
+/**
+ * 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";
+};
+/**
+ * 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, 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 as refund policy `prorated`
+ *   describes, minus the new configuration's cost for the remaining time at the change item's
+ *   `refund_monthly_amount` and `refund_hourly_amount`.
+ * - `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;
+    /**
+     * Summary of the parts in `transactions`.
+     *
+     * - `pending`: nothing has been returned yet, and at least one part is in progress.
+     * - `processing`: some parts have been returned, and at least one is still in progress.
+     * - `succeeded`: every part has been returned.
+     * - `failed`: no part is in progress and at least one has failed. What was returned is in
+     *   settled_amount.
+     *
+     * Returns to the balance and to credit grants complete shortly after the refund is made; a
+     * return to a payment method completes when the gateway confirms it.
+     */
+    status: RefundStatus;
+    /** When the last part was returned. Present with `succeeded`. */
+    settled_at?: string;
+    reason: RefundReason;
+    created_at: string;
+}
+export interface RefundList {
+    items: Refund[];
+    pagination: OffsetPagination;
+}
+/**
+ * The dimension values the rate was matched by, such as region and machine type.
+ */
+export type UsageChargeDimensions = {
+    [key: string]: string;
+};
+export interface UsageCharge {
+    subscription_id: string;
+    id: string;
+    project_id?: string;
+    /** The project and its current name. 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;
+    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;
+}
+export type SubscriptionInterval = (typeof SubscriptionInterval)[keyof typeof SubscriptionInterval];
+export declare const SubscriptionInterval: {
+    readonly none: "none";
+    readonly day: "day";
+    readonly month: "month";
+    readonly year: "year";
+};
+/**
+ * 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 subscription: 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;
+}
+/**
+ * `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. `suspended`: service is stopped while a lien restricts its use. `canceled`: cancellation 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 suspended: "suspended";
+    readonly canceled: "canceled";
+    readonly terminated: "terminated";
+};
+/**
+ * The dimension values of what was bought, such as region and instance type. Empty when the purchase gave none.
+ */
+export type SubscriptionDimensions = {
+    [key: string]: string;
+};
+/**
+ * A purchase that is billed, renewed and changed on its own, separate from the owning service's resource. A new
+ * recurring purchase creates a pending subscription for each order line; its ID is returned on the order item
+ * and stays the same through checkout, delivery, renewals and changes. A one-time purchase may create none.
+ *
+ * Pending and provisioning subscriptions grant no service. A subscription becomes provisioning when the owning
+ * service accepts the order, and active when the service confirms delivery, which sets started_at; payment
+ * changes neither. Licensed service periods start at delivery, and metered usage is charged as the service
+ * reports it. Canceling or failing an undelivered purchase cancels its subscriptions without starting a period.
+ * Renewals use recurring_amount and the agreed interval; paid periods keep their value.
+ *
+ * A shared capacity limit, such as a regional snapshot quota, has one subscription for the purchased quantity
+ * rather than one per item.
+ */
+export interface Subscription {
+    /** 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;
+    currency: 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: SubscriptionDimensions;
+    interval: SubscriptionInterval;
+    /** @minimum 1 */
+    interval_count?: number;
+    /** The whole licensed subscription's renewal amount, after continuing discounts and before tax. A pending subscription shows base terms until paying the order fixes any new discount. Absent for metered and one-time subscriptions. */
+    recurring_amount?: string;
+    termination_policy?: TerminationPolicy;
+    refund_policy?: RefundPolicy;
+    order_item_id?: string;
+    coupon_id?: string;
+    coupon?: ObjectIdentity;
+    /** @minimum 0 */
+    discounted_renewals_remaining?: number;
+    /** The operations currently prevented on the subscription, sorted; it is suspended while this contains `billing.subscriptions.use`. */
+    restrictions?: SubscriptionRestriction[];
+    billing_cycle_anchor?: string;
+    cancellation?: SubscriptionCancellation;
+    /** The accepted period-end change scheduled for this subscription; null when there is none. */
+    scheduled_change?: ScheduledChange | null;
+    /**
+     * 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;
+    created_at?: string;
+    id: string;
+    /** The billing account that made the purchase. Renewals of a project subscription are charged to the project's current billing account. */
+    billing_account_id: number;
+    account: AccountIdentity;
+    product_id: ProductID;
+    /**
+     * 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;
+    product: Product;
+    plan_id: string;
+    plan_name: string;
+    price_id: string;
+    quantity: string;
+    /**
+     * When a licensed subscription renews or expires: the end of the last period bought, moved by renewing in advance. Null until the subscription becomes active, even when its purchase has been paid, and for metered subscriptions.
+     * @nullable
+     */
+    current_term_end?: string | null;
+    /**
+     * Start of the service period in effect now. Null when none is, including for metered subscriptions.
+     * @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 for metered subscriptions.
+     * @nullable
+     */
+    current_period_end?: string | null;
+    /** Whether a licensed subscription renews automatically. A metered subscription continues until it is canceled; for it this is true until a cancellation is requested, and cannot be set. */
+    auto_renew: boolean;
+    /** `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. `suspended`: service is stopped while a lien restricts its use. `canceled`: cancellation completed, or an undelivered purchase was canceled or failed. `terminated`: an operator or the owning service ended it immediately. */
+    status: SubscriptionStatus;
+    /**
+     * 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 RenewalPriceInterval = (typeof RenewalPriceInterval)[keyof typeof RenewalPriceInterval];
+export declare const RenewalPriceInterval: {
+    readonly day: "day";
+    readonly month: "month";
+    readonly year: "year";
+};
+export interface RenewalPrice {
+    termination_policy?: TerminationPolicy;
+    refund_policy?: RefundPolicy;
+    price_id: string;
+    /** How many periods one renewal covers. */
+    interval_count: number;
+    interval: RenewalPriceInterval;
+    /** What renewing for this term costs, for the quantity held. */
+    amount?: Money;
+    currency?: string;
+    /** The term the subscription renews at now; renewing for it keeps the agreed price. */
+    current: boolean;
+}
+export interface RenewalPriceList {
+    items: RenewalPrice[];
+    pagination: OffsetPagination;
+}
+/**
+ * The unit interval_count counts in.
+ */
+export type RenewRequestInterval = (typeof RenewRequestInterval)[keyof typeof RenewRequestInterval];
+export declare const RenewRequestInterval: {
+    readonly day: "day";
+    readonly month: "month";
+    readonly year: "year";
+};
+export interface RenewRequest {
+    /** 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, each at the price the subscription 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 at the price this item already bills at, which a later price
+     * change does not affect. Naming a term that differs from the current one is a fresh
+     * choice, so it is bought at today's price. Naming the current term changes nothing. A
+     * term sold at several prices that differ in termination policy is refused with 409
+     * `BILLING_RENEWAL_OPTION_AMBIGUOUS` unless `termination_policy` is given.
+     *
+     * List the terms on offer with the renewal prices operation.
+     * @minimum 1
+     */
+    interval_count?: number;
+    /** The unit interval_count counts in. */
+    interval?: RenewRequestInterval;
+    /** With `interval` and `interval_count`, chooses among prices of that term that differ in termination policy. */
+    termination_policy?: TerminationPolicy;
+    payment_method_id?: string;
+    /** Whether to pay from the balance, with or without `payment_method_id`. */
+    use_balance?: boolean;
+    /** Whether to pay from eligible credit grants before the balance. */
+    use_credits?: boolean;
+    return_url?: string;
+}
+/**
+ * As in renewing.
+ */
+export type RenewalOrderRequestInterval = (typeof RenewalOrderRequestInterval)[keyof typeof RenewalOrderRequestInterval];
+export declare const RenewalOrderRequestInterval: {
+    readonly day: "day";
+    readonly month: "month";
+    readonly year: "year";
+};
+/**
+ * The renewal's periods and price, chosen as in renewing.
+ */
+export interface RenewalOrderRequest {
+    /** The order ID, chosen by the caller. Creating it again conflicts; read the order after an unknown outcome. */
+    order_id: string;
+    /**
+     * As in renewing.
+     * @minimum 1
+     */
+    periods?: number;
+    /**
+     * As in renewing.
+     * @minimum 1
+     */
+    interval_count?: number;
+    /** As in renewing. */
+    interval?: RenewalOrderRequestInterval;
+    /** As in renewing. */
+    termination_policy?: TerminationPolicy;
+}
+export interface AutoRenewSet {
+    auto_renew: boolean;
+}
+/**
+ * `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 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";
+};
+/**
+ * `new` buys, `renew` extends a licensed subscription, `modify` changes a subscription's 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 shortly before the current paid period ends and starts when it ends; if the invoice is unpaid by then, the order is canceled and the subscription renews or ends as usual. A renewal in the meantime moves the change to the end of the renewed period.
+ */
+export type OrderChangeEffective = (typeof OrderChangeEffective)[keyof typeof OrderChangeEffective];
+export declare const OrderChangeEffective: {
+    readonly none: "none";
+    readonly immediate: "immediate";
+    readonly period_end: "period_end";
+};
+/**
+ * An order's invoice amounts, without contact details or payment methods. A draft shows base prices until it is paid, when the discount is applied and it is issued; a zero-total invoice is issued and paid at placement.
+ */
+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;
+}
+export type OrderItemInterval = (typeof OrderItemInterval)[keyof typeof OrderItemInterval];
+export declare const OrderItemInterval: {
+    readonly none: "none";
+    readonly day: "day";
+    readonly month: "month";
+    readonly year: "year";
+};
+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 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 new pending subscription of a recurring purchase, or the existing one renewed or changed, which keeps its ID. Absent for a purchase without a subscription. */
+    subscription_id?: string;
+    interval: OrderItemInterval;
+    /** @minimum 1 */
+    interval_count?: number;
+    termination_policy?: TerminationPolicy;
+    refund_policy?: RefundPolicy;
+    /**
+     * Recurring licensed items only: the plan's one-month licensed price for this item's quantity, before tax and frozen at purchase, used to value time under a prorated refund or a downgrade. Null when the plan has no licensed period shorter than the one bought.
+     * @nullable
+     */
+    refund_monthly_amount?: string | null;
+    /**
+     * Recurring licensed items only, the plan's metered hourly price for this item's quantity before tax, frozen at purchase, used for time used short of a full month. Null when the licensed price has no meter.
+     * @nullable
+     */
+    refund_hourly_amount?: string | 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 with its invoice from placement; a zero-total invoice, such as for a metered purchase, is issued and paid at placement in either checkout mode. Until checkout_confirmed_at is set, the invoice is a draft at base prices: paying it fixes the discount and amount, issues it and collects it, and the order cannot be accepted before then. Coupon fields describe the discount fixed then and are absent before. 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's invoice is not issued and the 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 a licensed subscription, `modify` changes a subscription's 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 shortly before the current paid period ends and starts when it ends; if the invoice is unpaid by then, the order is canceled and the subscription renews or ends as usual. A renewal in the meantime moves the change to the end of the renewed period. */
+    change_effective?: OrderChangeEffective;
+    /**
+     * Acceptance deadline; a pending order expires after it.
+     * @nullable
+     */
+    expires_at?: string | null;
+    /**
+     * When the discount and amount were fixed: at placement for automatic checkout or a zero total, otherwise when the invoice was first paid. Null while a deferred order awaits payment.
+     * @nullable
+     */
+    checkout_confirmed_at?: string | null;
+    created_at: string;
+    /** What was bought. */
+    items: OrderItem[];
+}
+export interface OrderList {
+    items: Order[];
+    pagination: OffsetPagination;
+}
+/**
+ * `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";
+};
+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";
+};
+/**
+ * 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;
+    /** `scheduled` before valid_from, `active` within the validity, `expired` after valid_until, or `voided` once withdrawn. */
+    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 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;
+    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 ends. Absent for a metered subscription.
+     * @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";
+};
+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;
+}
+export interface Price {
+    rate_card?: ObjectIdentity;
+    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;
+    termination_policy?: TerminationPolicy;
+    refund_policy?: RefundPolicy;
+    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[];
+    /** Present when the price delegates to a rate card, the price list its rates are read from. */
+    rate_card_id?: string;
+    /** The smallest quantity that can be bought. Absent means no lower bound. */
+    min_quantity?: string;
+    /** The largest 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 dimension values this rate applies to, such as region and machine type.
+ */
+export type RateDimensions = {
+    [key: string]: string;
+};
+/**
+ * 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 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 RateList {
+    items: Rate[];
+    pagination: OffsetPagination;
+}
+export type QuoteItemInputInterval = (typeof QuoteItemInputInterval)[keyof typeof QuoteItemInputInterval];
+export declare const QuoteItemInputInterval: {
+    readonly none: "none";
+    readonly day: "day";
+    readonly month: "month";
+    readonly year: "year";
+};
+/**
+ * The dimension values the rate depends on, such as region, instance type or token kind: those of the usage for a metered estimate, and those of what is bought for a licensed price on a rate card. 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 rather than priced at zero.
+ */
+export type QuoteItemInputDimensions = {
+    [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. For a metered price, a meter or duration_seconds requests a usage estimate, which cannot be combined with a promotion code and is not a checkout amount. Without one, a metered item includes only any setup charge.
+ */
+export interface QuoteItemInput {
+    /**
+     * @minLength 1
+     * @maxLength 128
+     */
+    price_lookup_key?: string;
+    /**
+     * @minLength 1
+     * @maxLength 128
+     */
+    plan_lookup_key?: string;
+    price_id?: string;
+    product_id?: ProductID;
+    plan_id?: string;
+    /** Narrows the selection when a plan offers more than one price type. */
+    price_type?: PriceType;
+    /** Narrows the selection when a plan offers more than one usage type. */
+    usage_type?: UsageType;
+    interval?: QuoteItemInputInterval;
+    /** @minimum 1 */
+    interval_count?: number;
+    /** Selects among licensed prices with otherwise identical billing terms. Ambiguous terms are refused instead of choosing a price arbitrarily. */
+    termination_policy?: TerminationPolicy;
+    /** @pattern ^(?:(?:[1-9][0-9]{0,27}|0(?:[1-9][0-9]{0,26}|0(?:[1-9][0-9]{0,25}|0(?:[1-9][0-9]{0,24}|0(?:[1-9][0-9]{0,23}|0(?:[1-9][0-9]{0,22}|0(?:[1-9][0-9]{0,21}|0(?:[1-9][0-9]{0,20}|0(?:[1-9][0-9]{0,19}|0(?:[1-9][0-9]{0,18}|0(?:[1-9][0-9]{0,17}|0(?:[1-9][0-9]{0,16}|0(?:[1-9][0-9]{0,15}|0(?:[1-9][0-9]{0,14}|0(?:[1-9][0-9]{0,13}|0(?:[1-9][0-9]{0,12}|0(?:[1-9][0-9]{0,11}|0(?:[1-9][0-9]{0,10}|0(?:[1-9][0-9]{0,9}|0(?:[1-9][0-9]{0,8}|0(?:[1-9][0-9]{0,7}|0(?:[1-9][0-9]{0,6}|0(?:[1-9][0-9]{0,5}|0(?:[1-9][0-9]{0,4}|0(?:[1-9][0-9]{0,3}|0(?:[1-9][0-9]{0,2}|0(?:[1-9][0-9]{0,1}|0[1-9])))))))))))))))))))))))))))([.][0-9]{1,10})?|0{1,28}[.](?:[1-9][0-9]{0,9}|0(?:[1-9][0-9]{0,8}|0(?:[1-9][0-9]{0,7}|0(?:[1-9][0-9]{0,6}|0(?:[1-9][0-9]{0,5}|0(?:[1-9][0-9]{0,4}|0(?:[1-9][0-9]{0,3}|0(?:[1-9][0-9]{0,2}|0(?:[1-9][0-9]{0,1}|0[1-9]))))))))))$ */
+    quantity: string;
+    meter_id?: string;
+    /**
+     * @minLength 1
+     * @maxLength 128
+     */
+    meter_lookup_key?: string;
+    /** The dimension values the rate depends on, such as region, instance type or token kind: those of the usage for a metered estimate, and those of what is bought for a licensed price on a rate card. 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 rather than priced at zero. */
+    dimensions?: QuoteItemInputDimensions;
+    /** For a metered estimate, how long to price for, in seconds; the priced quantity is `quantity` times this duration. */
+    duration_seconds?: number;
+}
+/**
+ * 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 charged for this metering record. */
+    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 estimate of the refundable value of an order or selected items; nothing is canceled or refunded.
+ */
+export interface OrderRefundQuoteInput {
+    order_id: string;
+    /**
+     * Estimate only these items. Omit to estimate the whole order. Every item must belong to the order.
+     * @minItems 1
+     * @maxItems 100
+     */
+    order_item_ids?: string[];
+}
+/**
+ * Quote exactly one target for the billing account: proposed items, an existing order, renewals, a cancellation or an order refund. Promotion codes apply only to proposed items or an existing order. An invalid combination fails with `BILLING_PURCHASE_INVALID` and the field.
+ */
+export interface QuoteRequest {
+    /**
+     * The billing account to price for; it must be yours. Existing orders must have been placed with it, and renewals and cancellations must currently be paid by it.
+     * @minimum 1
+     */
+    billing_account_id: number;
+    /**
+     * A proposed purchase priced in the account's currency. Metered items may include usage estimates, which are not checkout amounts.
+     * @minItems 1
+     * @maxItems 100
+     */
+    items?: QuoteItemInput[];
+    /** Preview paying this order. Its recorded terms supply every line, and an order whose terms are fixed returns its recorded amounts. The order does not change. */
+    order_id?: string;
+    /**
+     * Preview renewing these subscriptions, each at most once; each entry is a separate renewal order. To preview a promotion code, create a renewal order and quote it by order_id.
+     * @minItems 1
+     * @maxItems 100
+     */
+    renewals?: QuoteRenewal[];
+    cancellation?: QuoteCancellation;
+    /**
+     * @minLength 1
+     * @maxLength 64
+     */
+    promotion_code?: string;
+    refund?: OrderRefundQuoteInput;
+}
+/**
+ * Pagination metadata for keyset traversal. Pass next_cursor as cursor to read the following page; null means there is no following page.
+ */
+export interface CursorPagination {
+    /** @minimum 1 */
+    page_size: number;
+    /** @nullable */
+    next_cursor?: string | null;
+}
+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 interface CancelSubscriptionRequest {
+    mode: TerminationPolicy;
+    /** For immediate cancellation, the quoted whole-second refund basis. Now when omitted. */
+    proration_date?: string;
+    /** The cancellation quote'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;
+}
+/**
+ * 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 of yours; all 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. It does not grant access to other billing accounts.
+ */
+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;
+};
+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;
+};
+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. It does not grant access to other billing accounts.
+     * @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 of yours; all when omitted.
+     */
+    billing_account_id?: AccountIdQueryParameter;
+};
+export type ListPaymentMethodsParams = {
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+    /**
+     * Only this account of yours; all when omitted.
+     */
+    billing_account_id?: AccountIdQueryParameter;
+};
+export type PreviewInvoicePaymentParams = {
+    /**
+     * As in paying; used only while the order's terms are not fixed.
+     * @minLength 1
+     * @maxLength 64
+     */
+    promotion_code?: string;
+    /**
+     * 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 of yours; all when omitted.
+     */
+    billing_account_id?: AccountIdQueryParameter;
+    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 of yours; all when omitted.
+     */
+    billing_account_id?: AccountIdQueryParameter;
+    from?: FromParameter;
+    /**
+     * Exclusive.
+     */
+    to?: ToParameter;
+};
+export type ListAccountDiscountsParams = {
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+    /**
+     * Only this account of yours; all when omitted.
+     */
+    billing_account_id?: AccountIdQueryParameter;
+};
+export type ListCreditGrantsParams = {
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+    /**
+     * Only this account of yours; all when omitted.
+     */
+    billing_account_id?: AccountIdQueryParameter;
+    status?: ListCreditGrantsStatus;
+};
+export type ListCreditGrantsStatus = (typeof ListCreditGrantsStatus)[keyof typeof ListCreditGrantsStatus];
+export declare const ListCreditGrantsStatus: {
+    readonly active: "active";
+    readonly depleted: "depleted";
+    readonly expired: "expired";
+    readonly voided: "voided";
+};
+export type 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 of yours; all when omitted.
+     */
+    billing_account_id?: AccountIdQueryParameter;
+    /**
+     * Only the notes for this invoice.
+     */
+    invoice_id?: string;
+};
+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 of yours; all 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;
+};
+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 of yours; all 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. It does not grant access to other billing accounts.
+     * @minItems 1
+     * @maxItems 100
+     */
+    project_ids?: ProjectIdsQueryParameter;
+    meter_id?: string;
+    statement_id?: string;
+};
+export type ListSubscriptionsParams = {
+    expiring_before?: string;
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+    /**
+     * Only this account of yours; all when omitted.
+     */
+    billing_account_id?: AccountIdQueryParameter;
+    /**
+     * Only records of these projects. Omit for all projects and account-level records. It does not grant access to other billing accounts.
+     * @minItems 1
+     * @maxItems 100
+     */
+    project_ids?: ProjectIdsQueryParameter;
+};
+export type ListCancellationsParams = {
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+    /**
+     * Only this account of yours; all when omitted.
+     */
+    billing_account_id?: AccountIdQueryParameter;
+    /**
+     * Only cancellations that include this subscription.
+     */
+    subscription_id?: string;
+    /**
+     * Only cancellations in this status. `open` means requested, scheduled or releasing.
+     */
+    status?: ListCancellationsStatus;
+    /**
+     * Only records of these projects. Omit for all projects and account-level records. It does not grant access to other billing accounts.
+     * @minItems 1
+     * @maxItems 100
+     */
+    project_ids?: ProjectIdsQueryParameter;
+};
+export type ListCancellationsStatus = (typeof ListCancellationsStatus)[keyof typeof ListCancellationsStatus];
+export declare const ListCancellationsStatus: {
+    readonly open: "open";
+    readonly requested: "requested";
+    readonly scheduled: "scheduled";
+    readonly releasing: "releasing";
+    readonly completed: "completed";
+    readonly canceled: "canceled";
+    readonly failed: "failed";
+};
+export type ListRenewalPricesParams = {
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+};
+export type ListAllowancesParams = {
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+    /**
+     * Only this account of yours; all when omitted.
+     */
+    billing_account_id?: AccountIdQueryParameter;
+    /**
+     * Filter by the meter UUID.
+     */
+    meter_id?: string;
+    status?: ListAllowancesStatus;
+    product_id?: ProductID;
+    /**
+     * Only records of these projects. Omit for all projects and account-level records. It does not grant access to other billing accounts.
+     * @minItems 1
+     * @maxItems 100
+     */
+    project_ids?: ProjectIdsQueryParameter;
+};
+export type ListAllowancesStatus = (typeof ListAllowancesStatus)[keyof typeof ListAllowancesStatus];
+export declare const ListAllowancesStatus: {
+    readonly active: "active";
+    readonly depleted: "depleted";
+    readonly expired: "expired";
+    readonly voided: "voided";
+};
+export type ListOrdersParams = {
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+    /**
+     * Only this account of yours; all when omitted.
+     */
+    billing_account_id?: AccountIdQueryParameter;
+    status?: OrderStatus;
+    from?: FromParameter;
+    /**
+     * Exclusive.
+     */
+    to?: ToParameter;
+    /**
+     * Only records of these projects. Omit for all projects and account-level records. It does not grant access to other billing accounts.
+     * @minItems 1
+     * @maxItems 100
+     */
+    project_ids?: ProjectIdsQueryParameter;
+};
+export type ListOrderItemsParams = {
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+};
+export type ListEntitlementsParams = {
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+    /**
+     * Only this account of yours; all when omitted.
+     */
+    billing_account_id?: AccountIdQueryParameter;
+    /**
+     * Only records of these projects. Omit for all projects and account-level records. It does not grant access to other billing accounts.
+     * @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 of yours; all when omitted.
+     */
+    billing_account_id?: AccountIdQueryParameter;
+    product_id?: ProductID;
+    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;
+};
+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 ListRatesParams = {
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+    /**
+     * Filter by the meter UUID.
+     */
+    meter_id?: string;
+    /**
+     * Rates in effect at this moment; defaults to now.
+     */
+    at?: string;
+};
+export type ListRatesHeaders = {
+    /**
+     * 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 of yours; all when omitted.
+     */
+    billing_account_id?: AccountIdQueryParameter;
+    /**
+     * Only records of these projects. Omit for all projects and account-level records. It does not grant access to other billing accounts.
+     * @minItems 1
+     * @maxItems 100
+     */
+    project_ids?: ProjectIdsQueryParameter;
+    meter_id?: string;
+    product_id?: ProductID;
+    status?: ListActiveResourcesStatus;
+};
+export type ListActiveResourcesStatus = (typeof ListActiveResourcesStatus)[keyof typeof ListActiveResourcesStatus];
+export declare const ListActiveResourcesStatus: {
+    readonly active: "active";
+    readonly suspended: "suspended";
+    readonly closing: "closing";
+    readonly closed: "closed";
+};
+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. It does not grant access to other billing accounts.
+     * @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;
+    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";
+};