@leaflow/sdk 0.121.0 → 0.123.0

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

@@ -340,7 +340,7 @@ export declare const ServiceResourceStatus: {
     readonly failed: "failed";
 };
 /**
- * Why the enablement failed; null unless `status` is `failed`. `order_declined` means Billing did not accept the order, for example because the billing account is suspended; `order_canceled` means the order was withdrawn; `order_expired` means its checkout was not confirmed in time.
+ * Why the enablement failed; null unless `status` is `failed`. `order_declined` means Billing did not accept the order, for example because the billing account is suspended; `order_canceled` means the order was withdrawn; `order_expired` means it was not paid in time.
  * @nullable
  */
 export type ServiceResourceFailureReason = (typeof ServiceResourceFailureReason)[keyof typeof ServiceResourceFailureReason] | null;
@@ -356,7 +356,7 @@ export interface ServiceResource {
     /** `inactive` has never been enabled or its subscription has ended; `pending` awaits acceptance of its order; `active` accepts requests on the forwarding endpoints; `failed` means the enablement failed, as `failure_reason` states. An `inactive` or `failed` service can be enabled again. */
     status: ServiceResourceStatus;
     /**
-     * Why the enablement failed; null unless `status` is `failed`. `order_declined` means Billing did not accept the order, for example because the billing account is suspended; `order_canceled` means the order was withdrawn; `order_expired` means its checkout was not confirmed in time.
+     * Why the enablement failed; null unless `status` is `failed`. `order_declined` means Billing did not accept the order, for example because the billing account is suspended; `order_canceled` means the order was withdrawn; `order_expired` means it was not paid in time.
      * @nullable
      */
     failure_reason: ServiceResourceFailureReason;
@@ -382,12 +382,13 @@ export interface ServiceResource {
     ended_at: string | null;
 }
 /**
- * automatic confirms checkout with applicable account discounts and collects payment from eligible
- * credit grants and available balance. Insufficient funds fail the purchase with HTTP 422
+ * automatic applies the best applicable account discount, issues the invoice and pays it from eligible
+ * credit grants and available balance at placement. Insufficient funds fail the purchase with HTTP 422
  * BILLING_INSUFFICIENT_FUNDS; no Billing order, charge or discount redemption is committed.
- * deferred creates a pending_checkout order for subsequent confirmation and payment through Billing.
- * No new discount redemption or payment is made when the order is created. An order whose total is
- * zero, with nothing to pay or discount, completes checkout at placement in either mode.
+ * deferred places the order with a draft invoice at base prices and collects nothing. Paying that
+ * invoice through Billing applies a promotion code or the best applicable account discount, issues the
+ * invoice and collects it; an order still unpaid at its deadline expires. A zero-total invoice is issued
+ * and paid at placement in either mode.
  */
 export type CheckoutMode = (typeof CheckoutMode)[keyof typeof CheckoutMode];
 export declare const CheckoutMode: {
@@ -397,7 +398,7 @@ export declare const CheckoutMode: {
 /**
  * Shared checkout choices for a product purchase. Omitting this object or mode selects
  * automatic checkout. Each purchase creates its own order. Promotion codes are supplied only to
- * Billing quote and checkout operations. A service may retain a failed creation record when Billing
+ * Billing quote and payment operations. A service may retain a failed creation record when Billing
  * refuses a purchase; no infrastructure is created for that refusal.
  */
 export interface CheckoutOptions {
@@ -406,7 +407,7 @@ export interface CheckoutOptions {
      * Expected invoice total after discounts and tax, before applying credit grants or balance.
      * A different total fails with BILLING_AMOUNT_CHANGED without charging or reserving a discount.
      * Accepted only in automatic mode; with deferred it is refused with HTTP 400. For deferred
-     * checkout, confirm the amount through Billing.
+     * checkout, give the expected amount when paying the invoice through Billing.
      */
     expected_amount?: Money & string;
 }
@@ -414,16 +415,70 @@ export interface CreateServiceRequestBody {
     checkout?: CheckoutOptions;
 }
 /**
- * Identifies the purchase. Read the order for purchase progress and its invoice for amounts and payment status.
+ * A draft is not yet issued. The draft invoice of an order shows base prices until it is paid, when
+ * the discount is applied and it is issued; other drafts are private to administrators.
+ * An issued invoice is open until settled; a zero-total issued invoice is immediately paid.
+ * Unbilled usage remains separate from invoices until it is invoiced.
+ * A refund does not change the status: a paid invoice stays paid, with the refunded part in
+ * amount_refunded. void means collection has stopped and any funds received have been returned.
  */
-export interface PlacedOrder {
+export type InvoiceStatus = (typeof InvoiceStatus)[keyof typeof InvoiceStatus];
+export declare const InvoiceStatus: {
+    readonly draft: "draft";
+    readonly open: "open";
+    readonly paid: "paid";
+    readonly void: "void";
+    readonly uncollectible: "uncollectible";
+};
+/**
+ * Purchase-related invoice amounts, without account contact details or payment methods. Every order
+ * has an invoice from placement. 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 whatever the
+ * checkout mode. Neither establishes acceptance or delivery.
+ */
+export interface InvoiceSummary {
+    id: string;
+    number?: string;
+    currency: string;
+    status: InvoiceStatus;
     /**
-     * The invoice for this purchase, which may still be a draft awaiting checkout. Null when no invoice has been created. Its presence or absence does not establish whether delivery may begin.
-     * @nullable
+     * 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, non-void credit notes that reduced unpaid receivables. Does not rewrite the original invoice total. */
+    pre_payment_credit_notes_amount: Money;
+    /** Issued credit notes against payments already received. This is a return obligation, not evidence of completed refunds. */
+    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})?$
      */
-    invoice_id: string | null;
-    /** The order, including for purchases without an immediate charge. Payment alone does not imply that the service has completed delivery. */
+    amount_due: string;
+    amount_refunded: string;
+    due_at?: string;
+}
+/**
+ * The Billing order this purchase placed and its invoice as they stood at placement. Read the order and
+ * the invoice in Billing for current progress: the service starts delivery only after Billing accepts the
+ * order, and payment alone does not mean delivery has completed.
+ */
+export interface PlacedOrder {
     order_id: string;
+    /** The order's invoice, the same as invoice.id. */
+    invoice_id: string;
+    /**
+     * What the purchase charges. A draft shows the base price in total and is paid through Billing, where a
+     * promotion code can still be applied; an open invoice is issued and awaits its amount_due; a paid one
+     * needs nothing further. A zero-total invoice is issued and paid at placement.
+     */
+    invoice: InvoiceSummary;
 }
 /**
  * The service, `pending` until its order is accepted, and the order.
@@ -437,7 +492,7 @@ export interface CreateServiceResponseBody {
  * A line without an immediate charge has zero checkout amounts. unit_amount remains null when
  * no single unit price applies; an unrequested usage estimate remains null.
  */
-export interface QuoteItem {
+export interface QuoteItemDc1fddb {
     plan_name: string;
     /**
      * Unit price before discounts, with tax included only where the price includes it. Null when
@@ -478,7 +533,7 @@ export interface QuoteItem {
  */
 export interface Quote {
     /** One line for each item the purchase would order, in the order it would order them. */
-    items: QuoteItem[];
+    items: QuoteItemDc1fddb[];
     /**
      * Sum of line amounts before discounts, less tax already included in the discounted line
      * amounts, as on an invoice.
@@ -531,6 +586,2817 @@ export interface CursorPagination {
     /** @nullable */
     next_cursor?: string | null;
 }
+/**
+ * How tax applies to the customer, as in Stripe. `none` taxes normally. `exempt` charges no tax.
+ * `reverse` charges no tax and leaves it to the customer under the reverse-charge mechanism;
+ * invoices state this. 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 billing-account contact profile with one address. An account can hold multiple contacts; this is not a login identity.
+ */
+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 and leaves it to the customer under the reverse-charge mechanism;
+     * invoices state this. 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;
+}
+/**
+ * Whether a fulfilled purchase may end immediately or only after its paid term. Does not grant a refund. When absent, the terms are not configured and termination requires review.
+ */
+export type TerminationPolicy = (typeof TerminationPolicy)[keyof typeof TerminationPolicy];
+export declare const TerminationPolicy: {
+    readonly immediate: "immediate";
+    readonly period_end: "period_end";
+};
+/**
+ * none refunds nothing. prorated refunds the amount paid for the current period minus the value of
+ * the time used, never below zero and never more than what remains unrefunded. The time used runs
+ * from the period start to the effective cancellation time and is valued at the plan's
+ * shorter-period prices in the same currency, frozen at purchase as the order item's
+ * refund_monthly_amount and refund_hourly_amount: each full calendar month at the one-month prepaid
+ * price, the remainder at the postpaid hourly price or, without one, at the one-month price by the
+ * second. When the plan has no prepaid period shorter than the one bought, the time used is valued
+ * at the price paid, pro rata by the second. Discounts are not refunded, as they were never paid,
+ * and setup fees are excluded. The refunded part returns to the payment sources it came from. Tax
+ * paid is refunded in the same proportion as the amount it was paid on.
+ */
+export type RefundPolicy = (typeof RefundPolicy)[keyof typeof RefundPolicy];
+export declare const RefundPolicy: {
+    readonly none: "none";
+    readonly prorated: "prorated";
+};
+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 prepaid subscription. Give `price_id`, or `interval` with
+ * `interval_count`, to renew for another term at the price currently sold for it. Naming
+ * the current term, or giving neither, renews at the agreed amount. A term sold at several
+ * prices that differ in termination policy is refused with 409
+ * `BILLING_RENEWAL_OPTION_AMBIGUOUS` unless `termination_policy` or `price_id` is given.
+ */
+export interface QuoteRenewal {
+    subscription_id: string;
+    price_id?: string;
+    interval?: QuoteRenewalInterval;
+    /** @minimum 1 */
+    interval_count?: number;
+    /** With `interval` and `interval_count`, chooses among prices of that term that differ in termination policy. */
+    termination_policy?: TerminationPolicy;
+    /**
+     * How many consecutive periods to renew for.
+     * @minimum 1
+     * @maximum 100
+     */
+    periods?: number;
+}
+export type QuoteRenewalResultInterval = (typeof QuoteRenewalResultInterval)[keyof typeof QuoteRenewalResultInterval];
+export declare const QuoteRenewalResultInterval: {
+    readonly day: "day";
+    readonly month: "month";
+    readonly year: "year";
+};
+/**
+ * What renewing would charge. Renewing the same subscription for the same term and number
+ * of periods charges exactly `total`, unless prices or the discounts the account holds
+ * change in between.
+ */
+export interface QuoteRenewalResult {
+    /** Which renewal of the request this answers. */
+    index: number;
+    subscription_id: string;
+    /** The price the renewal is charged under. */
+    price_id: string;
+    interval: QuoteRenewalResultInterval;
+    interval_count: number;
+    periods: number;
+    /**
+     * The price of the periods before the discounts the account holds. A discount the
+     * subscription already carries is reflected here. Contains tax only where the price
+     * itself includes it.
+     */
+    amount: Money;
+    /** The reduction from a discount the account holds. */
+    discount_amount: Money;
+    /** Tax on the discounted amount. */
+    tax_amount: Money;
+    /** The part of `tax_amount` already contained in `amount`. */
+    tax_included_amount: Money;
+    /**
+     * What renewing would charge: `amount` less `discount_amount`, plus `tax_amount`, less
+     * `tax_included_amount`.
+     */
+    total: Money;
+}
+/**
+ * One fully calculated purchase, estimated postpaid usage or recorded order item. Amounts use the
+ * billing-account currency. An item with no immediate charge has zero checkout amounts.
+ */
+export interface QuoteItem {
+    tax_amount: Money;
+    tax_included_amount: Money;
+    /**
+     * Zero-based request line index, or the recorded order item's position for an order quote.
+     * @minimum 0
+     */
+    index: number;
+    /** Present for an existing order quote; identifies the recorded item being priced. */
+    order_item_id?: string;
+    /** The selected price, including when the request identified it indirectly. */
+    price_id: string;
+    plan_name: string;
+    /** Unit price before discounts. Null when no single unit price applies, such as tiered or multiple-rate pricing. */
+    unit_amount: Money | null;
+    /** The quantity priced. When duration_seconds is supplied for metered usage, this is quantity multiplied by that duration. */
+    quantity: string;
+    /** Amount before discounts and including any setup charge. For requested future usage this is an estimate, not a collectible checkout amount. */
+    amount: Money;
+    discount_amount: Money;
+    total: Money;
+    currency: string;
+}
+export type QuotedDiscountType = (typeof QuotedDiscountType)[keyof typeof QuotedDiscountType];
+export declare const QuotedDiscountType: {
+    readonly promotion_code: "promotion_code";
+    readonly account_discount: "account_discount";
+};
+/**
+ * The discount selected for this calculation. Its presence in a quote does not apply it or
+ * reserve a redemption. Discount amounts are reported on the quote and its lines.
+ */
+export interface QuotedDiscount {
+    type: QuotedDiscountType;
+    name: string;
+    /**
+     * Code text for a promotion_code discount; null for an account_discount.
+     * @minLength 1
+     * @maxLength 64
+     * @nullable
+     */
+    promotion_code: string | null;
+}
+/**
+ * Which object this is, together with what a person currently calls it.
+ *
+ * The name is for display. It is chosen by whoever owns the object, it changes, it is not unique
+ * between objects, and it may be empty when nobody has named it yet — so it must not be used to
+ * address, match or deduplicate anything. Addressing is by id.
+ *
+ * This differs from an identity carrying a lookup key: a lookup key is written once by an operator,
+ * is unique, and can be used to fetch the object. A name cannot.
+ */
+export interface NamedIdentity {
+    id: string;
+    /** @maxLength 255 */
+    name: string;
+}
+export type CancellationRefundPreviewItemChargeType = (typeof CancellationRefundPreviewItemChargeType)[keyof typeof CancellationRefundPreviewItemChargeType];
+export declare const CancellationRefundPreviewItemChargeType: {
+    readonly postpaid: "postpaid";
+    readonly prepaid: "prepaid";
+    readonly one_time: "one_time";
+};
+/**
+ * One subscription of the quoted cancellation. The amounts mean what they mean in the total.
+ */
+export interface CancellationRefundPreviewItem {
+    subscription_id: string;
+    plan_id: string;
+    plan_name: string;
+    /**
+     * The project and its current name, for display. Absent for a purchase at account level, and when the
+     * project details cannot be read at the moment.
+     */
+    project?: NamedIdentity | null;
+    charge_type: CancellationRefundPreviewItemChargeType;
+    /**
+     * Whether automatic renewal is on now. Creating the cancellation turns it off. Withdrawing the
+     * cancellation does not turn it back on for a prepaid subscription; a postpaid subscription continues
+     * until it is canceled and turns it back on.
+     */
+    auto_renew: boolean;
+    unused_amount: Money;
+    refundable_amount: Money;
+    refund_amount: Money;
+    credit_amount: Money;
+    tax_amount: Money;
+    forfeited_amount: Money;
+}
+/**
+ * What the cancellation would return, subscription by subscription and in total, as of now. Give
+ * `proration_date` and `refundable_amount` when creating the cancellation.
+ *
+ * - `unused_amount`: before tax, the amount paid for the current periods minus the value of the
+ *   time used, valued as refund policy `prorated` describes, whatever the refund terms say.
+ * - `refundable_amount`: what is returned the way it was paid, including the tax paid on it;
+ *   `refund_amount` plus `credit_amount`.
+ * - `refund_amount`: the part returned to the balance or to the payment method.
+ * - `credit_amount`: the part restored to the credit grants that paid.
+ * - `tax_amount`: the tax included in `refundable_amount`.
+ * - `forfeited_amount`: before tax, the part of `unused_amount` the refund terms do not return.
+ *
+ * Postpaid and one-time subscriptions show zero; usage until release is charged as usual.
+ */
+export interface CancellationRefundPreview {
+    mode: TerminationPolicy;
+    /** For `period_end`, when release begins, the end of the paid terms. */
+    scheduled_at?: string;
+    /** For `immediate`, the second the refund is computed as of. Give it when creating the cancellation. */
+    proration_date?: string;
+    currency: string;
+    unused_amount: Money;
+    refundable_amount: Money;
+    refund_amount: Money;
+    credit_amount: Money;
+    tax_amount: Money;
+    forfeited_amount: Money;
+    items: CancellationRefundPreviewItem[];
+}
+/**
+ * An estimated refund to original payment sources. Before acceptance, cancellation returns the
+ * collected amount. For delivered service, only value funded by this order is included; renewals
+ * are evaluated under their own orders and the agreed termination terms apply. An unknown
+ * delivery outcome is not evidence that a refund is eligible. This calculation does not create
+ * a refund; the amount returned is determined when cancellation or termination is confirmed.
+ */
+export interface OrderRefundQuote {
+    order_id: string;
+    refundable_amount: Money;
+    refund_amount: Money;
+    credit_amount: Money;
+    currency: string;
+}
+/**
+ * A complete calculation in one billing-account currency, without saving a quote or reserving funds or
+ * redemptions. The request fails if any item cannot be priced. Requested future usage estimates are
+ * included in totals for reporting and are not collectible at checkout. Only an existing-order quote
+ * provides that order's checkout amount.
+ */
+export interface Quote5f60d00 {
+    subtotal: Money;
+    discount_amount: Money;
+    tax_amount: Money;
+    /**
+     * The discount evaluated for a purchase or order, without applying it. Null when none is selected or
+     * when quoting renewals or a cancellation. A confirmed order reports its recorded discount.
+     */
+    discount: QuotedDiscount | null;
+    items: QuoteItem[];
+    renewals: QuoteRenewalResult[];
+    /** What the cancellation requested would return. Present only when one was requested. */
+    cancellation?: CancellationRefundPreview;
+    total: Money;
+    currency: string;
+    /** Present only when an order refund was requested. Nothing is collectible for this target. */
+    refund?: OrderRefundQuote;
+}
+export type QuoteA200529 = Quote5f60d00;
+/**
+ * A cancellation to quote: what ending these subscriptions together would return. One mode per
+ * request; to compare, quote `immediate` and `period_end` separately.
+ *
+ * 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 still waiting to switch (`meta.order_id`).
+ */
+export interface QuoteCancellation {
+    /**
+     * The subscriptions to end together, all of one service. Every subscription released with a resource must be included.
+     * @minItems 1
+     * @maxItems 50
+     */
+    subscription_ids: string[];
+    mode: TerminationPolicy;
+}
+export interface CancellationCreate {
+    /**
+     * As in the quote.
+     * @minItems 1
+     * @maxItems 50
+     */
+    subscription_ids: string[];
+    mode: TerminationPolicy;
+    /**
+     * For `immediate`, the `proration_date` of the quote: a whole second, not in the future and
+     * at most ten minutes old. The refund is computed as of it. Now when omitted.
+     */
+    proration_date?: string;
+    /** The `refundable_amount` of the quote. The cancellation is refused when the refund differs. */
+    expected_refundable_amount: Money & string;
+    /**
+     * A note from the account holder. It is kept with the cancellation and not shown elsewhere.
+     * @maxLength 1024
+     */
+    reason?: string;
+}
+export type CancellationStatus = (typeof CancellationStatus)[keyof typeof CancellationStatus];
+export declare const CancellationStatus: {
+    readonly requested: "requested";
+    readonly scheduled: "scheduled";
+    readonly releasing: "releasing";
+    readonly completed: "completed";
+    readonly canceled: "canceled";
+    readonly failed: "failed";
+};
+/**
+ * Who asked for it. `project_deletion` means the project was deleted.
+ */
+export type CancellationOrigin = (typeof CancellationOrigin)[keyof typeof CancellationOrigin];
+export declare const CancellationOrigin: {
+    readonly customer: "customer";
+    readonly operator: "operator";
+    readonly project_deletion: "project_deletion";
+};
+/**
+ * How the subscription is charged. Creating the cancellation turned automatic renewal off;
+ * withdrawing it turns renewal back on for a `postpaid` subscription and leaves it off for a
+ * `prepaid` one.
+ */
+export type CancellationItemChargeType = (typeof CancellationItemChargeType)[keyof typeof CancellationItemChargeType];
+export declare const CancellationItemChargeType: {
+    readonly postpaid: "postpaid";
+    readonly prepaid: "prepaid";
+    readonly one_time: "one_time";
+};
+export type CancellationItemStatus = (typeof CancellationItemStatus)[keyof typeof CancellationItemStatus];
+export declare const CancellationItemStatus: {
+    readonly requested: "requested";
+    readonly scheduled: "scheduled";
+    readonly releasing: "releasing";
+    readonly completed: "completed";
+    readonly canceled: "canceled";
+    readonly failed: "failed";
+};
+/**
+ * One subscription of the cancellation.
+ */
+export interface CancellationItem {
+    /** The cancellation item of this subscription, the same as `Subscription.cancellation.id`. */
+    id: string;
+    subscription_id: string;
+    plan_id: string;
+    plan_name: string;
+    /**
+     * How the subscription is charged. Creating the cancellation turned automatic renewal off;
+     * withdrawing it turns renewal back on for a `postpaid` subscription and leaves it off for a
+     * `prepaid` one.
+     */
+    charge_type: CancellationItemChargeType;
+    status: CancellationItemStatus;
+    /** Execution stopped or its result is unknown. Present while release still requires resolution; it does not establish refund eligibility. */
+    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 asked for it. `project_deletion` means the project was deleted. */
+    origin: CancellationOrigin;
+    /**
+     * The billing account that paid for these subscriptions when the cancellation was created: the
+     * account of an account-level purchase, or the account the project was linked to.
+     */
+    billing_account_id: number;
+    currency: string;
+    /** The refund confirmed when it was created. Absent when the platform created it. */
+    expected_refundable_amount?: Money;
+    /**
+     * Present with `failed`. A code of the service that provides the resources, such as a disk
+     * that can only be released with its server. Clients map it to their own wording.
+     */
+    failure_code?: string;
+    requested_at: string;
+    completed_at?: string;
+    canceled_at?: string;
+    items: CancellationItem[];
+}
+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 that includes the subscription, with this subscription's item. `id` is the
+ * item; `cancellation_id` is the cancellation. scheduled_at is the intended time; effective_at is the
+ * confirmed end of service. A cancellation alone does not stop metering or issue a refund.
+ */
+export interface SubscriptionCancellation {
+    reason?: string;
+    /** The cancellation this request 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;
+}
+export type ErrorA200529 = Error;
+/**
+ * Immutable platform service identifier, such as compute, canopy or assistant.
+ * @minLength 1
+ * @maxLength 64
+ * @pattern ^[a-z][a-z0-9]*(-[a-z0-9]+)*$
+ */
+export type ProductID = string;
+export interface Product {
+    id: ProductID;
+    name: string;
+    description?: string;
+}
+export type BillingAccountStatus = (typeof BillingAccountStatus)[keyof typeof BillingAccountStatus];
+export declare const BillingAccountStatus: {
+    readonly active: "active";
+    readonly suspended: "suspended";
+    readonly closed: "closed";
+};
+export interface BillingAccount {
+    /**
+     * The active contact used for invoicing. Must belong to this account; null clears the selection.
+     * @nullable
+     */
+    invoice_contact_id?: string | null;
+    id: number;
+    /** What you call this account. */
+    name?: string;
+    /** Fixed when the account was opened. */
+    currency: string;
+    status: BillingAccountStatus;
+    /**
+     * How far past the suspension threshold this account may go before its resources are
+     * suspended. "0" means none: the account is suspended as soon as it crosses the threshold.
+     */
+    grace_amount?: string;
+    /**
+     * How long this account has to top up after crossing the suspension threshold.
+     * 0 means none. Whichever runs out first — this or grace_amount — ends the grace.
+     */
+    grace_period_seconds?: number;
+    /**
+     * The actual time this account was closed, in UTC (RFC 3339).
+     * Null or absent if the account is not closed or its historical close 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 currency, the ISO 4217 minor unit.
+     * @minimum 0
+     * @maximum 4
+     */
+    exponent: number;
+    /**
+     * @minLength 1
+     * @maxLength 64
+     */
+    name: string;
+    minimum_top_up: Money;
+}
+export interface CurrencyList {
+    items: Currency[];
+    pagination: OffsetPagination;
+}
+export interface BillingAccountCreate {
+    /**
+     * @minLength 3
+     * @maxLength 3
+     */
+    currency: string;
+    /** @maxLength 255 */
+    name?: string;
+}
+export interface BillingAccountUpdate {
+    /**
+     * The active contact used for invoicing. Must belong to this account; null clears the selection.
+     * @nullable
+     */
+    invoice_contact_id?: string | null;
+    /** @maxLength 255 */
+    name?: string;
+}
+export interface BillingAccountList {
+    items: BillingAccount[];
+    pagination: OffsetPagination;
+}
+/**
+ * A plan it refers to. active is false once the plan is archived; it still applies to subscriptions already on this plan.
+ */
+export interface ApplicablePlan {
+    id: string;
+    name: string;
+    active: boolean;
+}
+/**
+ * A catalog object inlined for display.
+ */
+export interface ObjectIdentity {
+    lookup_key?: string;
+    id: string;
+    name: string;
+}
+export type PriceOptionBillingScheme = (typeof PriceOptionBillingScheme)[keyof typeof PriceOptionBillingScheme];
+export declare const PriceOptionBillingScheme: {
+    readonly per_unit: "per_unit";
+    readonly tiered: "tiered";
+    readonly rated: "rated";
+};
+export type PriceOptionType = (typeof PriceOptionType)[keyof typeof PriceOptionType];
+export declare const PriceOptionType: {
+    readonly postpaid: "postpaid";
+    readonly prepaid: "prepaid";
+    readonly one_time: "one_time";
+};
+export type PriceOptionInterval = (typeof PriceOptionInterval)[keyof typeof PriceOptionInterval];
+export declare const PriceOptionInterval: {
+    readonly none: "none";
+    readonly day: "day";
+    readonly month: "month";
+    readonly year: "year";
+};
+/**
+ * A price's display terms, including archived prices referenced by an applicability list.
+ */
+export interface PriceOption {
+    product: Product;
+    plan: ObjectIdentity;
+    billing_scheme: PriceOptionBillingScheme;
+    unit_quantity: string;
+    id: string;
+    currency: string;
+    type: PriceOptionType;
+    interval: PriceOptionInterval;
+    /** How many periods one purchase covers. */
+    interval_count?: number;
+    unit_amount?: Money;
+    /** False once the price is archived. It still applies to purchases already made at this price. */
+    active: boolean;
+}
+/**
+ * Which purchase operation this applies to. `new` covers every new purchase, including
+ * zero-charge purchases. It does not mean the account's first purchase; use
+ * `first_purchase_only` for that restriction. `renew` covers renewals. `modify` covers
+ * configuration or billing-term changes, including changes that increase or decrease
+ * the amount due and changes with no additional charge or refund.
+ */
+export type PurchaseOperation = (typeof PurchaseOperation)[keyof typeof PurchaseOperation];
+export declare const PurchaseOperation: {
+    readonly new: "new";
+    readonly renew: "renew";
+    readonly modify: "modify";
+};
+/**
+ * Anything not excluded that matches an inclusion, or anything not excluded when no inclusion is
+ * given, subject to the charge type, operation and term conditions. Entries always include their
+ * display fields; archived plans and prices stay listed with active set to false.
+ */
+export interface Applicability {
+    products?: Product[];
+    plans?: ApplicablePlan[];
+    prices?: PriceOption[];
+    price_types?: string[];
+    operations?: PurchaseOperation[];
+    /**
+     * The shortest term a purchase may have, in months. A purchase with no term, such as
+     * metered usage, never qualifies while this is set.
+     */
+    min_term_months?: number;
+    /** The longest term a purchase may have, in months. */
+    max_term_months?: number;
+    excluded_products?: Product[];
+    excluded_plans?: ApplicablePlan[];
+    excluded_prices?: PriceOption[];
+}
+export interface CreditGroup {
+    /** What the credit in this group may pay for. No restrictions means anything on the account. */
+    applies_to: Applicability;
+    /** Restricted to your first purchase of anything it applies to. */
+    first_purchase_only?: boolean;
+    amount: Money;
+}
+/**
+ * Account balance, credits, and unpaid charges are reported separately.
+ */
+export interface AccountBalance {
+    /** Balance minus pending balance returns, unbilled usage estimates and issued unpaid amounts. Credit grants are excluded; the result may be negative. */
+    available_credit: Money;
+    /** Current estimate of rated usage that has not been invoiced. Final pricing and tax are fixed at issuance. */
+    unbilled_amount: Money;
+    billing_account_id: number;
+    currency: string;
+    /**
+     * Prepaid funds in the account currency, excluding credits. May be negative after a payment
+     * dispute. Outstanding charges are reported separately in due; this value is not a withdrawal quote.
+     */
+    balance: Money;
+    /**
+     * The recorded remaining credit, including restricted grants. It is not withdrawable
+     * and is not part of balance. credit_groups describes currently valid credit by permitted use; a positive
+     * credits balance does not imply that due is zero.
+     */
+    credits: Money;
+    /** Currently valid credit whose use has applicable product, operation or eligibility conditions. Included in credits, separate from the balance. */
+    restricted_credits: Money;
+    /**
+     * Currently valid, unspent credit grouped by permitted use. Restrictions and
+     * validity dates determine which charges a group can cover, so these groups are not a general
+     * spendable balance and may differ from the recorded credits total.
+     */
+    credit_groups: CreditGroup[];
+    /** Amount still payable on issued invoices. Unbilled usage is reported separately; arrears depend on actual eligible funding and grace terms. */
+    due: Money;
+    pending_returns_amount: Money;
+}
+/**
+ * A project's assignment to a billing account for the interval from effective_from to effective_to. An open-ended assignment has no end time.
+ */
+export interface ProjectAssignment {
+    project_id: string;
+    /**
+     * The project and its current name, for display. Absent when the project no longer exists or its
+     * details cannot be read at the moment; `project_id` still identifies it.
+     */
+    project?: NamedIdentity | null;
+    billing_account_id: number;
+    account_name?: string;
+    currency: string;
+    effective_from: string;
+    /** @nullable */
+    effective_to?: string | null;
+}
+export interface ProjectAssignmentList {
+    items: ProjectAssignment[];
+    pagination: OffsetPagination;
+}
+export interface SetProjectAssignmentRequest {
+    billing_account_id: number;
+}
+/**
+ * `pending` until the payment gateway reaches a result. The balance increases on `succeeded`.
+ *
+ * `failed` means the gateway declined the payment. A declined attempt ends the top-up at once
+ * and the payment is withdrawn at the gateway; to pay another way, create a new top-up.
+ * `canceled` means the attempt was withdrawn without collecting money; `cancellation_reason`
+ * says why. Unknown gateway outcomes remain `pending`, and a browser redirect is not proof of
+ * payment.
+ *
+ * `failed` and `canceled` are final. If the gateway nevertheless collects payment for such an
+ * attempt, the amount is credited as a separate `succeeded` top-up.
+ */
+export type TopUpStatus = (typeof TopUpStatus)[keyof typeof TopUpStatus];
+export declare const TopUpStatus: {
+    readonly pending: "pending";
+    readonly succeeded: "succeeded";
+    readonly failed: "failed";
+    readonly canceled: "canceled";
+};
+export interface AccountIdentity {
+    id: number;
+    name: string;
+    currency: string;
+}
+/**
+ * Why a gateway payment was withdrawn. `abandoned` means the customer did not complete it within the time
+ * allowed for payment. `requested_by_customer` means the customer canceled it.
+ */
+export type PaymentCancellationReason = (typeof PaymentCancellationReason)[keyof typeof PaymentCancellationReason];
+export declare const PaymentCancellationReason: {
+    readonly abandoned: "abandoned";
+    readonly requested_by_customer: "requested_by_customer";
+};
+export type PaymentActionType = (typeof PaymentActionType)[keyof typeof PaymentActionType];
+export declare const PaymentActionType: {
+    readonly redirect: "redirect";
+    readonly qr_code: "qr_code";
+    readonly sdk: "sdk";
+};
+/**
+ * The customer's next interaction. The gateway reports the actual payment outcome separately.
+ */
+export interface PaymentAction {
+    type: PaymentActionType;
+    /** Identifies the browser adapter for an SDK action, for example stripe. */
+    provider?: string;
+    url?: string;
+    /** QR content to render and scan, not an image URL. */
+    qr_code?: string;
+    /** Short-lived client credential for this payment's browser confirmation. */
+    client_secret?: string;
+    public_key?: string;
+}
+/**
+ * A top-up attempt and its outcome. A successful top-up adds a traceable amount to the balance; it is not a credit grant and has no associated invoice.
+ */
+export interface TopUp {
+    id: string;
+    billing_account_id: number;
+    account: AccountIdentity;
+    /** What is credited to the account, in the account's own currency. */
+    amount: Money;
+    currency: string;
+    /**
+     * The part of this top-up still held in the balance. Pending refunds can temporarily
+     * reserve part of it; it is not a promise that the whole amount is immediately withdrawable.
+     */
+    remaining_amount?: Money;
+    /**
+     * `pending` until the payment gateway reaches a result. The balance increases on `succeeded`.
+     *
+     * `failed` means the gateway declined the payment. A declined attempt ends the top-up at once
+     * and the payment is withdrawn at the gateway; to pay another way, create a new top-up.
+     * `canceled` means the attempt was withdrawn without collecting money; `cancellation_reason`
+     * says why. Unknown gateway outcomes remain `pending`, and a browser redirect is not proof of
+     * payment.
+     *
+     * `failed` and `canceled` are final. If the gateway nevertheless collects payment for such an
+     * attempt, the amount is credited as a separate `succeeded` top-up.
+     */
+    status: TopUpStatus;
+    cancellation_reason?: PaymentCancellationReason;
+    /** Which payment gateway collected it. */
+    payment_gateway?: string;
+    /** The selected payment method, such as card, wechat_pay or alipay. */
+    method_type?: string;
+    /**
+     * The currency the customer was actually charged in, when the checkout page collected a
+     * local one. Absent when it was the same as the account's.
+     */
+    presentment_currency?: string;
+    /**
+     * What was charged, in `presentment_currency`. It will not equal `amount`, and it is
+     * the figure that appears on the customer's card or wallet statement.
+     */
+    presentment_amount?: Money;
+    /**
+     * Why the gateway declined it. Present with `failed`. The value is the gateway's own code,
+     * passed on unchanged: the card issuer's decline code when there is one (Stripe's decline_code,
+     * such as insufficient_funds or lost_card), otherwise the gateway's error code (Stripe's code,
+     * such as card_declined, expired_card or payment_intent_authentication_failure). Clients map it
+     * to their own wording and treat an unknown value as a generic decline.
+     */
+    failure_reason?: string;
+    action?: PaymentAction;
+    created_at: string;
+    /**
+     * When the funds arrived. Later than `created_at` — by days for a bank transfer — so
+     * reconciling against a statement uses this rather than the moment it was started.
+     * Absent until the payment completes.
+     * @nullable
+     */
+    settled_at?: string | null;
+}
+export interface TopUpCreate {
+    /**
+     * The gateway explicitly selected from the available payment options.
+     * @minLength 1
+     * @maxLength 32
+     */
+    payment_gateway: string;
+    /**
+     * The selected method, such as card, wechat_pay or alipay.
+     * @minLength 1
+     * @maxLength 64
+     */
+    method_type: string;
+    /** The ID of this top-up attempt. Keep it before submitting and query it after an uncertain response. */
+    id: string;
+    billing_account_id: number;
+    /**
+     * In the account's currency, and no finer than that currency's smallest unit:
+     * two decimals for most, none for the yen. A finer amount is refused here rather
+     * than at the checkout page, where the customer would see the gateway's own wording
+     * instead of an explanation.
+     *
+     * There is a minimum, which differs by currency. Below it the gateway's fee
+     * exceeds the top-up itself, so such a payment costs more to accept than it brings.
+     * The minimum in force is returned with the rejection.
+     */
+    amount: Money & string;
+    /** Charge a saved method instead of opening a checkout page. */
+    payment_method_id?: string;
+    /** Where to send the customer after checkout. */
+    return_url?: string;
+}
+export interface TopUpList {
+    items: TopUp[];
+    pagination: OffsetPagination;
+}
+export interface PaymentOptionMethod {
+    /** The value to send as `method_type`, such as card, wechat_pay or alipay. */
+    method_type: string;
+    /**
+     * Whether a method of this type can be saved with create-payment-method-setup and charged later
+     * without the customer present. Methods that are not reusable are paid anew each time.
+     */
+    reusable: boolean;
+}
+/**
+ * A payment gateway that accepts payment in the account's currency, with the methods it accepts.
+ */
+export interface PaymentOption {
+    /** The value to send as `payment_gateway`. */
+    payment_gateway: string;
+    methods: PaymentOptionMethod[];
+}
+export interface PaymentOptionList {
+    items: PaymentOption[];
+    pagination: OffsetPagination;
+}
+export type PaymentMethodStatus = (typeof PaymentMethodStatus)[keyof typeof PaymentMethodStatus];
+export declare const PaymentMethodStatus: {
+    readonly active: "active";
+    readonly expired: "expired";
+    readonly removed: "removed";
+};
+export interface PaymentMethod {
+    id: string;
+    billing_account_id: number;
+    payment_gateway: string;
+    brand?: string;
+    last4?: string;
+    /** @nullable */
+    exp_month?: number | null;
+    /** @nullable */
+    exp_year?: number | null;
+    is_default: boolean;
+    status: PaymentMethodStatus;
+}
+export interface PaymentMethodList {
+    items: PaymentMethod[];
+    pagination: OffsetPagination;
+}
+export interface PaymentMethodSetup {
+    /**
+     * The selected gateway supporting saved payment methods.
+     * @minLength 1
+     * @maxLength 32
+     */
+    payment_gateway: string;
+    billing_account_id: number;
+}
+/**
+ * What the payment gateway's browser library needs in order to collect a card. There is
+ * no address to redirect to: the form is rendered in the page, and the card goes straight
+ * from the browser to the gateway.
+ */
+export interface PaymentMethodSetupResult {
+    /**
+     * The gateway's identifier for this attempt. Use it to tell a reloaded page apart
+     * from a second attempt.
+     */
+    setup_id: string;
+    payment_gateway: string;
+    action: PaymentAction;
+}
+/**
+ * Applies eligible credit grants and the available balance as requested, then collects only the remainder
+ * through the selected gateway. Grants restricted to other purchases are not counted as available funds.
+ * An unresolved channel payment is reused; retries do not apply the grant or balance portions twice.
+ * Without a gateway selection, insufficient account funds fail without starting an online payment.
+ *
+ * `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 original gateway.
+     * @minLength 1
+     * @maxLength 32
+     */
+    payment_gateway?: string;
+    /**
+     * Required with payment_gateway; for example card, wechat_pay or alipay.
+     * @minLength 1
+     * @maxLength 64
+     */
+    method_type?: string;
+    /** Optional saved card owned by this billing account and belonging to the selected gateway. Omit to complete payment interactively. */
+    payment_method_id?: string;
+    /** Whether to apply the available balance. Credit grants are controlled separately by use_credits. */
+    use_balance?: boolean;
+    /** Apply eligible, unexpired credit grants before using the balance. This never withdraws grants or converts them into balance. */
+    use_credits?: boolean;
+    return_url?: string;
+    /**
+     * The code to apply while the order's terms are not yet 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 comparison; an explicit zero is compared.
+     */
+    expected_amount?: Money & string;
+}
+/**
+ * Name at least one invoice or order. They must all belong to the same account and share
+ * its currency; anything else is refused rather than partly paid.
+ */
+export interface PayTogetherRequest {
+    /** @maxItems 100 */
+    invoice_ids?: string[];
+    /** @maxItems 100 */
+    order_ids?: string[];
+    /**
+     * The amount due to expect across all of them, 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 comparison.
+     */
+    expected_amount?: Money & string;
+}
+/**
+ * The current payment outcome.
+ *
+ * succeeded means payment is complete. processing means confirmation is pending; poll the invoice or
+ * order rather than submitting another payment. requires_action means the customer must complete the
+ * supplied action. failed means the attempt did not succeed and failure_reason explains the outcome; a
+ * declined gateway payment is withdrawn at the gateway, and paying again starts a new payment with the
+ * same or another method.
+ */
+export type PaymentStatus = (typeof PaymentStatus)[keyof typeof PaymentStatus];
+export declare const PaymentStatus: {
+    readonly succeeded: "succeeded";
+    readonly processing: "processing";
+    readonly requires_action: "requires_action";
+    readonly failed: "failed";
+};
+/**
+ * A credit grant and what it would pay.
+ */
+export interface AppliedCredit {
+    credit_grant_id: string;
+    name: string;
+    amount: Money;
+}
+export interface PaymentPreviewInvoice {
+    invoice_id: string;
+    /** @nullable */
+    order_id?: string | null;
+    amount_due: Money;
+    credit_applied: Money;
+    balance_applied: Money;
+}
+/**
+ * What paying would take, computed as paying computes it. Nothing is charged or reserved.
+ */
+export interface PaymentPreview {
+    currency: string;
+    /** What is outstanding before paying. */
+    amount_due: Money;
+    /** What credit grants would pay. Grants restricted to other purchases pay nothing here. */
+    credit_applied: Money;
+    /** The credit grants that would pay, in the order they would be used. */
+    credit_grants: AppliedCredit[];
+    /** What the balance would pay. */
+    balance_applied: Money;
+    /** What would remain to be paid online. Paying without a gateway is refused with `BILLING_INSUFFICIENT_FUNDS` while this is above zero. */
+    gateway_amount: Money;
+    /** The available balance after paying. */
+    balance_after: Money;
+    /** Paying together only. Each invoice, in the order it would be paid. */
+    invoices?: PaymentPreviewInvoice[];
+}
+/**
+ * Present on refunds. Where this part of the refund goes.
+ *
+ * - `balance`: back to the account balance.
+ * - `credit`: back to the credit grant that paid, which keeps its original expiry.
+ * - `gateway`: back to the payment method it was paid with.
+ */
+export type TransactionRefundDestination = (typeof TransactionRefundDestination)[keyof typeof TransactionRefundDestination];
+export declare const TransactionRefundDestination: {
+    readonly balance: "balance";
+    readonly credit: "credit";
+    readonly gateway: "gateway";
+};
+/**
+ * `failed` means the operation did not succeed; for a gateway payment, that the gateway declined
+ * it. `canceled` means a gateway payment was withdrawn without collecting money. After either,
+ * an invoice the payment was meant to pay remains open for another payment.
+ */
+export type TransactionStatus = (typeof TransactionStatus)[keyof typeof TransactionStatus];
+export declare const TransactionStatus: {
+    readonly pending: "pending";
+    readonly succeeded: "succeeded";
+    readonly failed: "failed";
+    readonly canceled: "canceled";
+};
+/**
+ * topup adds to the balance; payment settles an invoice; refund returns original funds; 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";
+};
+/**
+ * A funds operation. Each payment has one source; refunds identify the original successful transaction. Unknown gateway results remain pending. Payments from the balance or a gateway are distinct from credit-grant payments.
+ */
+export interface Transaction {
+    invoice_id?: string;
+    transaction_id?: string;
+    /** The credit grant that paid, or for a refund, the credit grant restored. */
+    credit_grant_id?: string;
+    credit_grant?: ObjectIdentity;
+    refund_id?: string;
+    /**
+     * Present on refunds. Where this part of the refund goes.
+     *
+     * - `balance`: back to the account balance.
+     * - `credit`: back to the credit grant that paid, which keeps its original expiry.
+     * - `gateway`: back to the payment method it was paid with.
+     */
+    refund_destination?: TransactionRefundDestination;
+    /**
+     * `failed` means the operation did not succeed; for a gateway payment, that the gateway declined
+     * it. `canceled` means a gateway payment was withdrawn without collecting money. After either,
+     * an invoice the payment was meant to pay remains open for another payment.
+     */
+    status?: TransactionStatus;
+    cancellation_reason?: PaymentCancellationReason;
+    payment_gateway?: string;
+    method_type?: string;
+    /**
+     * Why it failed. Present with `failed`. For a declined gateway payment the value is the
+     * gateway's own code, passed on unchanged: the card issuer's decline code when there is one
+     * (Stripe's decline_code, such as insufficient_funds or lost_card), otherwise the gateway's
+     * error code (Stripe's code, such as card_declined, expired_card or
+     * payment_intent_authentication_failure). Clients map it to their own wording and treat an
+     * unknown value as a generic decline.
+     */
+    failure_reason?: string;
+    settled_at?: string;
+    id: string;
+    billing_account_id?: number;
+    type: TransactionType;
+    /**
+     * Signed by type: positive for `topup` and `payment`, negative for `refund`.
+     * An `adjustment` is positive when it adds to the balance and negative when it takes from
+     * it. For the other types the sign does not tell the effect on the balance: a payment from
+     * the balance lowers it, while a payment by gateway or by credit leaves it unchanged.
+     */
+    amount: Money;
+    /**
+     * How much of this transaction is still available in the balance. Only top-ups, positive
+     * adjustments and gateway payments later returned to the balance can be non-zero.
+     */
+    remaining_amount: Money;
+    currency: string;
+    reason?: string;
+    created_at: string;
+}
+export interface PaymentResult {
+    transactions: Transaction[];
+    /** The gateway transaction, when one is involved. Balance and credit-grant payments are separate transactions. */
+    transaction_id?: string;
+    status: PaymentStatus;
+    amount_paid: Money;
+    /**
+     * What is still outstanding. Zero once the payment succeeds. Unchanged while
+     * `processing`: nothing is collected until the gateway confirms it.
+     */
+    amount_due: Money;
+    currency: string;
+    credit_applied?: Money;
+    gateway_amount?: Money;
+    payment_gateway?: string;
+    method_type?: string;
+    /**
+     * The amount already paid from the account's balance toward this invoice. Retrying an online remainder
+     * does not debit it again. A canceled purchase returns funds through its refund process.
+     */
+    balance_applied?: Money;
+    action?: PaymentAction;
+    /**
+     * Whether paying again is worth attempting. False for a refusal that will keep
+     * happening — a closed account, an amount over a limit — so that a client does not
+     * retry in a loop.
+     */
+    retriable?: boolean;
+    /** @nullable */
+    invoice_id?: string | null;
+    /** @nullable */
+    order_id?: string | null;
+    /**
+     * Why the payment did not go through. Present with `failed`. For a declined gateway payment the
+     * value is the gateway's own code, passed on unchanged: the card issuer's decline code when
+     * there is one (Stripe's decline_code, such as insufficient_funds or lost_card), otherwise the
+     * gateway's error code (Stripe's code, such as card_declined, expired_card or
+     * payment_intent_authentication_failure). Clients map it to their own wording and treat an
+     * unknown value as a generic decline.
+     */
+    failure_reason?: string;
+}
+/**
+ * How tax applied to the customer when the invoice was issued. `reverse` means no tax was
+ * charged because the customer accounts for it 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 been stopped; any accepted return obligations are completed before final voiding. */
+    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. Does not reduce the receivable or tax base. */
+    credit_applied?: Money;
+    /** Subtotal less discount plus tax. Balance and credit grants are payment sources, not reductions of the receivable. */
+    total: Money;
+    amount_paid?: Money;
+    /** Issued, non-void credit notes that reduced unpaid receivables. Does not rewrite the original invoice total. */
+    pre_payment_credit_notes_amount: Money;
+    /** Issued credit notes against payments already received. This is a return obligation, not evidence of completed refunds. */
+    post_payment_credit_notes_amount: Money;
+    /** What is still collectible after unpaid credit notes and successful payments; never below zero. A draft has none; its total is the base price, and a payment preview shows what paying it would collect. A paid or void invoice has none either. */
+    amount_due: Money;
+    /** @nullable */
+    period_start?: string | null;
+    /**
+     * Exclusive.
+     * @nullable
+     */
+    period_end?: string | null;
+    /**
+     * Who this was billed to, as recorded when the invoice was issued. Later changes to
+     * the account do not alter it.
+     */
+    customer_name?: string;
+    customer_email?: string;
+    customer_tax_id?: string;
+    /**
+     * How tax applied to the customer when the invoice was issued. `reverse` means no tax was
+     * charged because the customer accounts for it 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";
+};
+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, for display. Absent when the line is
+     * not for a project, and when the project no longer exists or its details cannot be read at
+     * the moment; `project_id` still identifies it then.
+     */
+    project?: NamedIdentity | null;
+    resource_id?: string;
+    /**
+     * The wording as recorded when the invoice was issued. It is not re-translated
+     * afterwards, so that an invoice continues to read as it did when it was sent.
+     */
+    description: string;
+    unit?: string;
+    quantity?: string;
+    /** The part covered by an included allowance, and therefore not charged. */
+    deducted_quantity?: string;
+    unit_amount?: Money;
+    amount: Money;
+    currency: string;
+    /** @nullable */
+    period_start?: string | null;
+    /** @nullable */
+    period_end?: string | null;
+}
+export interface InvoiceItemList {
+    items: InvoiceItem[];
+    pagination: OffsetPagination;
+}
+export interface TransactionList {
+    items: Transaction[];
+    pagination: OffsetPagination;
+}
+export type CreditGrantStatus = (typeof CreditGrantStatus)[keyof typeof CreditGrantStatus];
+export declare const CreditGrantStatus: {
+    readonly active: "active";
+    readonly depleted: "depleted";
+    readonly expired: "expired";
+    readonly voided: "voided";
+};
+export interface CreditGrant {
+    min_amount?: string;
+    id: string;
+    billing_account_id?: number;
+    name: string;
+    amount: Money;
+    remaining_amount: Money;
+    currency: string;
+    /** What this credit may pay for. No restrictions means anything on the account. */
+    applies_to: Applicability;
+    /** Restricted to your first purchase of anything it applies to. */
+    first_purchase_only?: boolean;
+    status: CreditGrantStatus;
+    valid_from: string;
+    /** @nullable */
+    valid_until?: string | null;
+}
+export interface CreditGrantList {
+    items: CreditGrant[];
+    pagination: OffsetPagination;
+}
+export type CreditNoteStatus = (typeof CreditNoteStatus)[keyof typeof CreditNoteStatus];
+export declare const CreditNoteStatus: {
+    readonly issued: "issued";
+    readonly void: "void";
+};
+/**
+ * Why the note was issued. Notes from canceled, expired or failed orders carry the order's reason;
+ * `usage_true_up` returns a tier price reduction settled after the original invoice; `operator` is
+ * issued by Leaflow 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";
+};
+/**
+ * An issued invoice reduction. Its credited amount is pre_payment_amount plus post_payment_amount. A paid credit records a return obligation; refund_id identifies its refund, whose outcome may still be pending. Original invoice amounts remain unchanged.
+ */
+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. This is not proof that its refund has completed. */
+    post_payment_amount: Money;
+    /**
+     * The refund to the original payment sources, or null when no paid amount was credited.
+     * @nullable
+     */
+    refund_id: string | null;
+    /**
+     * Why the note was issued. Notes from canceled, expired or failed orders carry the order's reason;
+     * `usage_true_up` returns a tier price reduction settled after the original invoice; `operator` is
+     * issued by Leaflow 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 several destinations.
+ * @deprecated
+ */
+export type RefundDestination = (typeof RefundDestination)[keyof typeof RefundDestination];
+export declare const RefundDestination: {
+    readonly balance: "balance";
+    readonly gateway: "gateway";
+};
+/**
+ * Summary of the parts in `transactions`.
+ *
+ * - `pending`: nothing has been returned yet, and at least one part is in progress.
+ * - `processing`: some parts have been returned, and at least one is still in progress.
+ * - `succeeded`: every part has been returned.
+ * - `failed`: no part is in progress and at least one has failed. What was returned is in
+ *   settled_amount.
+ *
+ * Returns to the balance and to credit grants complete shortly after the refund is made; a
+ * return to a payment method completes when the gateway confirms it.
+ */
+export type RefundStatus = (typeof RefundStatus)[keyof typeof RefundStatus];
+export declare const RefundStatus: {
+    readonly pending: "pending";
+    readonly processing: "processing";
+    readonly succeeded: "succeeded";
+    readonly failed: "failed";
+};
+/**
+ * Why the refund was made. Clients map the code to their own wording. More codes may be added;
+ * treat an unknown code as a refund without a stated reason.
+ *
+ * - `provisioning_failed`: the purchase could not be delivered.
+ * - `order_expired`: the order expired after part of it had been paid.
+ * - `order_canceled`: the account holder canceled the order after part of it had been paid.
+ * - `change_canceled`: a scheduled change was withdrawn after part of it had been paid.
+ * - `change_expired`: a scheduled change could not take effect before its time passed.
+ * - `subscription_canceled`: the subscription was canceled and its unused value returned under
+ *   its refund terms.
+ * - `future_period_canceled`: a renewal that had not started yet was withdrawn.
+ * - `downgrade_difference`: after a downgrade, the remaining value of what was paid, valued as refund
+ *   policy `prorated` describes, minus the new configuration's cost for the remaining time at the
+ *   change item's `refund_monthly_amount` and `refund_hourly_amount`. Nothing is refunded when that is
+ *   zero or less.
+ * - `usage_true_up`: usage priced again over the whole month cost less than was charged.
+ * - `payment_not_applied`: a payment arrived after its invoice could no longer be paid.
+ * - `operator`: made by the platform operator.
+ */
+export type RefundReason = (typeof RefundReason)[keyof typeof RefundReason];
+export declare const RefundReason: {
+    readonly provisioning_failed: "provisioning_failed";
+    readonly order_expired: "order_expired";
+    readonly order_canceled: "order_canceled";
+    readonly change_canceled: "change_canceled";
+    readonly change_expired: "change_expired";
+    readonly subscription_canceled: "subscription_canceled";
+    readonly future_period_canceled: "future_period_canceled";
+    readonly downgrade_difference: "downgrade_difference";
+    readonly usage_true_up: "usage_true_up";
+    readonly payment_not_applied: "payment_not_applied";
+    readonly operator: "operator";
+};
+export interface Refund {
+    transaction_id?: string;
+    cancellation_item_id?: string;
+    /** Original funds-return split and each result. Unknown gateway results remain pending. */
+    transactions: Transaction[];
+    id: string;
+    billing_account_id?: number;
+    /** @nullable */
+    invoice_id?: string | null;
+    /**
+     * The order the refund belongs to: the order that caused it, such as a downgrade, otherwise
+     * the order of the refunded invoice. Null for refunds of top-ups and of usage invoices.
+     * @nullable
+     */
+    order_id?: string | null;
+    /** The whole refund. Equals balance_amount plus credit_amount plus gateway_amount. */
+    amount: Money;
+    /** The part returned to the account balance. */
+    balance_amount: Money;
+    /** The part restored to the credit grants that paid for it. */
+    credit_amount: Money;
+    /** The part returned to the payment method it was paid with. */
+    gateway_amount: Money;
+    /** What has actually been returned. */
+    settled_amount?: Money;
+    currency: string;
+    /**
+     * Use balance_amount, credit_amount and gateway_amount, which also show a refund split between several destinations.
+     * @deprecated
+     */
+    destination?: RefundDestination;
+    /**
+     * Summary of the parts in `transactions`.
+     *
+     * - `pending`: nothing has been returned yet, and at least one part is in progress.
+     * - `processing`: some parts have been returned, and at least one is still in progress.
+     * - `succeeded`: every part has been returned.
+     * - `failed`: no part is in progress and at least one has failed. What was returned is in
+     *   settled_amount.
+     *
+     * Returns to the balance and to credit grants complete shortly after the refund is made; a
+     * return to a payment method completes when the gateway confirms it.
+     */
+    status: RefundStatus;
+    /** When the last part was returned. Present with `succeeded`. */
+    settled_at?: string;
+    reason: RefundReason;
+    created_at: string;
+}
+export interface RefundList {
+    items: Refund[];
+    pagination: OffsetPagination;
+}
+/**
+ * The attributes the rate was chosen by, such as region and machine type.
+ */
+export type UsageChargeDimensions = {
+    [key: string]: string;
+};
+export interface UsageCharge {
+    subscription_id: string;
+    id: string;
+    project_id?: string;
+    /**
+     * The project and its current name, for display. Absent when the project no longer exists or its
+     * details cannot be read at the moment; `project_id` still identifies it.
+     */
+    project?: NamedIdentity | null;
+    product: Product;
+    /** Which resource this was charged for. Empty for charges not tied to one. */
+    resource_id?: string;
+    meter: ObjectIdentity;
+    unit?: string;
+    /** The attributes the rate was chosen by, such as region and machine type. */
+    dimensions?: UsageChargeDimensions;
+    window_start: string;
+    /** Exclusive. */
+    window_end: string;
+    /** How much was used, before any included allowance. */
+    gross_quantity?: string;
+    /** How much of that was covered by an allowance. */
+    deducted_quantity?: string;
+    /** What was charged for — the gross quantity less the part covered. */
+    quantity: string;
+    unit_amount?: Money;
+    amount: Money;
+    currency: string;
+    /**
+     * 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 SubscriptionChargeType = (typeof SubscriptionChargeType)[keyof typeof SubscriptionChargeType];
+export declare const SubscriptionChargeType: {
+    readonly postpaid: "postpaid";
+    readonly prepaid: "prepaid";
+    readonly one_time: "one_time";
+};
+export type SubscriptionInterval = (typeof SubscriptionInterval)[keyof typeof SubscriptionInterval];
+export declare const SubscriptionInterval: {
+    readonly none: "none";
+    readonly day: "day";
+    readonly month: "month";
+    readonly year: "year";
+};
+/**
+ * pending means the purchase relationship exists but its order has not been accepted.
+ * provisioning means the service accepted the order and is delivering. For a service-owned
+ * purchase, only confirmed delivery moves it to active; paying alone does not.
+ * canceled means cancellation completed, or an unfulfilled purchase was canceled or failed without delivery.
+ * terminated means an administrator or the owning service immediately ended the commercial relationship.
+ */
+export type SubscriptionStatus = (typeof SubscriptionStatus)[keyof typeof SubscriptionStatus];
+export declare const SubscriptionStatus: {
+    readonly pending: "pending";
+    readonly provisioning: "provisioning";
+    readonly active: "active";
+    readonly suspended: "suspended";
+    readonly canceled: "canceled";
+    readonly terminated: "terminated";
+};
+/**
+ * An independently billed purchase relationship, separate from the owning service's resource.
+ * Placing a new prepaid or postpaid service order creates a pending subscription for each line
+ * in the same purchase transaction. Its ID is returned on the order item and remains stable
+ * through checkout and delivery. One order may create several subscriptions, such as an instance,
+ * its system disk and its address; it has no single subscription ID.
+ *
+ * Pending and provisioning do not grant service or accrue usage. A service-owned subscription
+ * becomes provisioning when the owning service accepts the order, and active when the service
+ * confirms delivery, with started_at set to the confirmed effective time; payment changes neither. Prepaid service periods start
+ * then; postpaid usage starts only when the service reports actual delivery and metering.
+ *
+ * One-time delivery may omit a subscription. Renewals reference and extend existing subscriptions
+ * rather than creating another; a change keeps the subscription ID and switches its terms when it
+ * takes effect. Canceling or failing an unfulfilled purchase sets its pending or provisioning
+ * subscriptions to canceled without starting a service period.
+ * Fixed renewals use the agreed recurring_amount and interval; already paid periods retain their
+ * original value. Technical state belongs to the owning service.
+ *
+ * A purchased shared capacity limit, such as a regional snapshot count quota, can have its own
+ * subscription. Activating that capacity confirms delivery of the quota, not individual snapshots.
+ * Creating or deleting snapshots within it does not create, activate or terminate more subscriptions;
+ * the owning service enforces current holdings against the purchased count.
+ */
+export interface Subscription {
+    currency: string;
+    charge_type: SubscriptionChargeType;
+    interval: SubscriptionInterval;
+    /** @minimum 1 */
+    interval_count?: number;
+    /**
+     * Whole-subscription prepaid renewal amount, after continuing discounts and before tax.
+     * Pending subscriptions show base terms until paying the order fixes any new continuing discount.
+     * Absent for other charge types.
+     */
+    recurring_amount?: string;
+    termination_policy?: TerminationPolicy;
+    refund_policy?: RefundPolicy;
+    order_item_id?: string;
+    /** Present only on subscriptions created by an earlier change that replaced the subscription. A change now keeps the subscription ID. */
+    replaces_subscription_id?: string;
+    coupon_id?: string;
+    coupon?: ObjectIdentity;
+    /** @minimum 0 */
+    discounted_renewals_remaining?: number;
+    suspend_reason?: string;
+    billing_cycle_anchor?: string;
+    cancellation?: SubscriptionCancellation;
+    /**
+     * The saved payment method automatic renewal charges after the account's balance and credits,
+     * before the account's default payment method. Set when the purchase, a renewal or a change is paid with a
+     * saved payment method; paying any other way leaves it unchanged. It is used only while it belongs to the
+     * account that pays 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;
+    /**
+     * Which project this is for. Absent when it was bought at account level, such as a
+     * membership, which belongs to no single project.
+     * @nullable
+     */
+    project_id?: string | null;
+    /**
+     * The project and its current name, for display. Absent for a purchase at account level,
+     * and when the project no longer exists or its details cannot be read at the moment;
+     * `project_id` still identifies it then.
+     */
+    project?: NamedIdentity | null;
+    product: Product;
+    plan_id: string;
+    plan_name: string;
+    price_id: string;
+    quantity: string;
+    /**
+     * When a prepaid subscription renews or expires, the end of the last service period bought.
+     * Renewing several periods in advance moves it. Null until a new subscription becomes active, even when
+     * its purchase has been paid, and for postpaid subscriptions.
+     * @nullable
+     */
+    current_term_end?: string | null;
+    /**
+     * Start of the service period in effect now. Null when none is, including for postpaid 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 postpaid subscriptions.
+     * @nullable
+     */
+    current_period_end?: string | null;
+    /** A prepaid subscription renews automatically while this is on. A postpaid subscription always continues until it is canceled; this is true until a cancellation is requested and cannot be set. */
+    auto_renew: boolean;
+    /**
+     * pending means the purchase relationship exists but its order has not been accepted.
+     * provisioning means the service accepted the order and is delivering. For a service-owned
+     * purchase, only confirmed delivery moves it to active; paying alone does not.
+     * canceled means cancellation completed, or an unfulfilled purchase was canceled or failed without delivery.
+     * terminated means an administrator or the owning service immediately ended the commercial relationship.
+     */
+    status: SubscriptionStatus;
+    /**
+     * Confirmed start of service. Null until a new subscription becomes active, including after payment.
+     * @nullable
+     */
+    started_at?: string | null;
+    /** @nullable */
+    ended_at?: string | null;
+}
+export interface SubscriptionList {
+    items: Subscription[];
+    pagination: OffsetPagination;
+}
+export type RenewalPriceInterval = (typeof RenewalPriceInterval)[keyof typeof RenewalPriceInterval];
+export declare const RenewalPriceInterval: {
+    readonly day: "day";
+    readonly month: "month";
+    readonly year: "year";
+};
+export interface RenewalPrice {
+    termination_policy?: TerminationPolicy;
+    refund_policy?: RefundPolicy;
+    price_id: string;
+    /** How many periods one renewal covers. */
+    interval_count: number;
+    interval: RenewalPriceInterval;
+    /** What renewing for this term costs, for the quantity held. */
+    amount?: Money;
+    currency?: string;
+    /**
+     * The term this item already bills at. Renewing for it uses the price bought
+     * originally, so a later price change does not affect it.
+     */
+    current: boolean;
+}
+export interface RenewalPriceList {
+    items: RenewalPrice[];
+    pagination: OffsetPagination;
+}
+/**
+ * The unit interval_count counts in.
+ */
+export type RenewRequestInterval = (typeof RenewRequestInterval)[keyof typeof RenewRequestInterval];
+export declare const RenewRequestInterval: {
+    readonly day: "day";
+    readonly month: "month";
+    readonly year: "year";
+};
+export interface RenewRequest {
+    /** Purchase ID saved before submitting. Duplicate creation conflicts; query this order after an unknown result. */
+    order_id: string;
+    /**
+     * How many further periods to buy, each at the price this item already bills at.
+     *
+     * Buying twelve monthly periods is not the same as buying one yearly term: a longer
+     * term is usually sold at a lower price, and that price is only reached by naming the
+     * interval. Use `interval_count` and `interval` for that.
+     * @minimum 1
+     */
+    periods?: number;
+    /**
+     * Renew for a term of this length instead, at the price currently sold for it. Give
+     * `interval` with it.
+     *
+     * Leaving both out renews at the price this item already bills at, which a later price
+     * change does not affect. Naming a term that differs from the current one is a fresh
+     * choice, so it is bought at today's price. Naming the current term changes nothing. A
+     * term sold at several prices that differ in termination policy is refused with 409
+     * `BILLING_RENEWAL_OPTION_AMBIGUOUS` unless `termination_policy` is given.
+     *
+     * List the terms on offer with the renewal prices operation.
+     * @minimum 1
+     */
+    interval_count?: number;
+    /** The unit interval_count counts in. */
+    interval?: RenewRequestInterval;
+    /** With `interval` and `interval_count`, chooses among prices of that term that differ in termination policy. */
+    termination_policy?: TerminationPolicy;
+    payment_method_id?: string;
+    /** Whether to pay from the balance, with or without `payment_method_id`. */
+    use_balance?: boolean;
+    /** Whether to pay from eligible credit grants before the balance. */
+    use_credits?: boolean;
+    return_url?: string;
+}
+/**
+ * As in renewing.
+ */
+export type RenewalOrderRequestInterval = (typeof RenewalOrderRequestInterval)[keyof typeof RenewalOrderRequestInterval];
+export declare const RenewalOrderRequestInterval: {
+    readonly day: "day";
+    readonly month: "month";
+    readonly year: "year";
+};
+/**
+ * The periods and price of the renewal, chosen as in renewing.
+ */
+export interface RenewalOrderRequest {
+    /** Purchase ID saved before submitting. Duplicate creation conflicts; query this order after an unknown result. */
+    order_id: string;
+    /**
+     * As in renewing.
+     * @minimum 1
+     */
+    periods?: number;
+    /**
+     * As in renewing.
+     * @minimum 1
+     */
+    interval_count?: number;
+    /** As in renewing. */
+    interval?: RenewalOrderRequestInterval;
+    /** As in renewing. */
+    termination_policy?: TerminationPolicy;
+}
+export interface AutoRenewSet {
+    auto_renew: boolean;
+}
+/**
+ * Follows the items. `pending` is not yet accepted and may be unpaid or paid; its invoice shows
+ * whether payment is still needed, and it can expire or be canceled. `accepted` is accepted with items still
+ * being set up. `completed` means every item was set up. `partially_completed` means some items were set up
+ * and the others failed or were canceled and were refunded to their original payment sources. `failed` means
+ * no item was delivered and at least one failed; collected amounts for the undelivered items are refunded.
+ * `canceled` means every item was withdrawn without delivery; collected amounts are returned to their original
+ * payment sources. No status establishes service delivery by itself.
+ */
+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";
+};
+/**
+ * `pending` is waiting to be set up. `completed` was confirmed by the service.
+ * `failed` was not set up and its amount was refunded to the original payment sources.
+ * `canceled` was confirmed withdrawn without delivery; any collected amount is returned. A completed item is ended by canceling
+ * its subscription.
+ */
+export type OrderItemStatus = (typeof OrderItemStatus)[keyof typeof OrderItemStatus];
+export declare const OrderItemStatus: {
+    readonly pending: "pending";
+    readonly completed: "completed";
+    readonly failed: "failed";
+    readonly canceled: "canceled";
+};
+/**
+ * `new` buys, `renew` extends a prepaid 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` on anything that is not a change.
+ *
+ * `period_end` orders stay pending until the first period at the new price is paid. That period
+ * is invoiced shortly before the current paid period ends and starts when it ends; if the
+ * invoice is still unpaid by then, the order is canceled and the subscription renews or ends as
+ * usual. Renewing in the meantime moves all of this along with it.
+ */
+export type OrderChangeEffective = (typeof OrderChangeEffective)[keyof typeof OrderChangeEffective];
+export declare const OrderChangeEffective: {
+    readonly none: "none";
+    readonly immediate: "immediate";
+    readonly period_end: "period_end";
+};
+/**
+ * How it was paid. Removing the payment method afterwards does not change it; `payment_method_id`
+ * then names a removed payment method.
+ */
+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";
+};
+/**
+ * The payment timing of the selected price.
+ */
+export type OrderItemChargeType = (typeof OrderItemChargeType)[keyof typeof OrderItemChargeType];
+export declare const OrderItemChargeType: {
+    readonly postpaid: "postpaid";
+    readonly prepaid: "prepaid";
+    readonly one_time: "one_time";
+};
+export type OrderItemConfiguration = {
+    [key: string]: unknown;
+};
+/**
+ * Frozen purchase terms. Monetary fields come from related invoice-line snapshots and are zero
+ * for a line with no immediate charge, such as postpaid admission. Later catalog changes do not reprice this line. A new service
+ * purchase creates its pending subscription when this item is recorded, not when payment succeeds.
+ */
+export interface OrderItem {
+    /** Financial lines produced by this purchase item, including setup charges. */
+    invoice_item_ids?: string[];
+    /** @minimum 0 */
+    position?: number;
+    configuration?: OrderItemConfiguration;
+    /**
+     * Stable Billing subscription ID. A new prepaid or postpaid service purchase returns the
+     * pending subscription here; renewals and changes reference the existing subscription, which
+     * keeps its ID. Absent for delivery without a subscription. This is not a business resource ID.
+     */
+    subscription_id?: string;
+    interval: OrderItemInterval;
+    /** @minimum 1 */
+    interval_count?: number;
+    termination_policy?: TerminationPolicy;
+    refund_policy?: RefundPolicy;
+    /**
+     * Prepaid items only: the plan's one-month prepaid price for this item's quantity before tax, frozen
+     * at purchase, used to value time used under a prorated refund or a downgrade. Null when the plan has
+     * no prepaid period shorter than the one bought.
+     * @nullable
+     */
+    refund_monthly_amount?: string | null;
+    /**
+     * Prepaid items only: the plan's postpaid hourly price for this item's quantity before tax, frozen at
+     * purchase, used for time used short of a full month. Null when the plan has no postpaid price.
+     * @nullable
+     */
+    refund_hourly_amount?: string | null;
+    completes_on_payment: boolean;
+    recurring_amount?: string;
+    setup_amount?: string;
+    /** The payment timing of the selected price. */
+    charge_type: OrderItemChargeType;
+    /** Total tax after discounts, including any tax already included in the price. */
+    tax_amount?: string;
+    /** The part of tax_amount already included in gross_amount; it is not charged again. */
+    tax_included_amount?: string;
+    id: string;
+    order_id?: string;
+    price_id: string;
+    product_id?: ProductID;
+    product?: Product;
+    /** Which plan was bought. */
+    plan_id: string;
+    /**
+     * What it was called when bought. It does not follow later catalogue renames and is
+     * not translated.
+     */
+    plan_name: string;
+    quantity: string;
+    /**
+     * The unit amount of the price this line is charged under. Absent for a tiered price, which has no
+     * single unit amount, and for a change that takes effect at once, which is charged as `gross_amount`
+     * describes.
+     */
+    unit_amount?: Money;
+    /**
+     * Before discounts: the price applied to the quantity, which for a per-unit price is `unit_amount`
+     * times `quantity`; a minimum charge can make it higher. For an upgrade that takes effect at once it is
+     * the new price minus the old price for the time left in the paid period, both at the subscription's
+     * own period price, and the period end does not move; a downgrade charges nothing and may refund the
+     * difference instead. A change between equal period prices charges and refunds nothing. The setup fee is not part of it; see `setup_amount`.
+     *
+     * Under an inclusive tax rate it includes tax, as the price does, and the included part is
+     * `tax_included_amount`. A renewal at the agreed terms is the exception: the agreed amount excludes
+     * tax, and tax is added to it.
+     */
+    gross_amount?: Money;
+    /**
+     * The reduction on this line: from the coupon the order uses and, for a renewal at the agreed terms,
+     * from the discount the subscription carries.
+     *
+     * A carried discount is part of the agreed amount. It is listed here, and `gross_amount` is then
+     * `unit_amount` times `quantity`, except in two cases where `gross_amount` is the agreed amount and
+     * the carried discount is already reflected in it: the renewal order also uses a coupon the account
+     * holds, or the account's tax rate is inclusive.
+     */
+    discount_amount?: Money;
+    /** `gross_amount` less `discount_amount`. */
+    amount?: Money;
+    currency: string;
+    /** @nullable */
+    period_start?: string | null;
+    /** @nullable */
+    period_end?: string | null;
+    status: OrderItemStatus;
+}
+/**
+ * A recorded purchase with its invoice from placement; a zero-total invoice, such as for postpaid
+ * admission, is issued and paid at placement whatever the 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 at that point and are absent
+ * before it; a quote never populates them. Payment and acceptance remain separate from resource delivery.
+ */
+export interface Order {
+    coupon_id?: string;
+    coupon?: ObjectIdentity;
+    promotion_code_id?: string;
+    /** Code text frozen when the coupon was 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;
+    /**
+     * Which project it was bought for. Absent for a purchase made at account level, such
+     * as a membership.
+     * @nullable
+     */
+    project_id?: string | null;
+    /**
+     * The project and its current name, for display. Absent for a purchase at account level,
+     * and when the project no longer exists or its details cannot be read at the moment;
+     * `project_id` still identifies it then.
+     */
+    project?: NamedIdentity | null;
+    /**
+     * The billing account the order was placed with. It does not change when the project is later
+     * linked to another billing account. While this account is suspended or closed the order cannot
+     * be accepted, and the invoice of a change scheduled for the end of a period 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 prepaid subscription, `modify` changes a subscription's configuration or billing terms. */
+    type: OrderType;
+    status: OrderStatus;
+    /**
+     * When a plan change takes effect. `none` on anything that is not a change.
+     *
+     * `period_end` orders stay pending until the first period at the new price is paid. That period
+     * is invoiced shortly before the current paid period ends and starts when it ends; if the
+     * invoice is still unpaid by then, the order is canceled and the subscription renews or ends as
+     * usual. Renewing in the meantime moves all of this along with it.
+     */
+    change_effective?: OrderChangeEffective;
+    /**
+     * Acceptance deadline. Pending orders can expire automatically.
+     * @nullable
+     */
+    expires_at?: string | null;
+    /**
+     * When the discount and amount were fixed: at placement for automatic checkout and for 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. Present on a single order and on every order in a list, so a list
+     * can be rendered without a further request per row.
+     */
+    items: OrderItem[];
+}
+export interface OrderList {
+    items: Order[];
+    pagination: OffsetPagination;
+}
+/**
+ * `scheduled` before valid_from, `active` within the validity, `expired` after valid_until, or
+ * `voided` once Leaflow withdrew it.
+ */
+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 of the purchased item. `once` applies only to the
+ * purchase or renewal that uses the coupon, `recurring` continues for `frequency_duration` billing
+ * periods including the first, and `forever` continues 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 on this account for a period. Within the period it applies without a code to purchases and
+ * to metered usage that the coupon 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 Leaflow withdrew it.
+     */
+    status: DiscountStatus;
+    voided_at?: string;
+    type: DiscountType;
+    /**
+     * Whether the discount continues on renewals of the purchased item. `once` applies only to the
+     * purchase or renewal that uses the coupon, `recurring` continues for `frequency_duration` billing
+     * periods including the first, and `forever` continues 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 be used for. Absent means it applies to anything on the account,
+     * including setup fees and traffic.
+     */
+    applies_to: Applicability;
+    /** Restricted to your first purchase of anything it applies to. */
+    first_purchase_only?: boolean;
+    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 of charge. 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 of charge. 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 take
+     * precedence.
+     */
+    priority?: number;
+    status: AllowanceStatus;
+    valid_from: string;
+    /**
+     * When it lapses. Anything unused at that point is lost; it is not refunded and does
+     * not carry over. Absent when it does not expire on its own.
+     * @nullable
+     */
+    valid_until?: string | null;
+}
+export interface AllowanceList {
+    items: Allowance[];
+    pagination: OffsetPagination;
+}
+/**
+ * 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 subscription providing it ends. Absent for a metered subscription, which
+     * has no end date.
+     * @nullable
+     */
+    expires_at?: string | null;
+}
+export interface EntitlementList {
+    items: Entitlement[];
+    pagination: OffsetPagination;
+}
+export interface ProductList {
+    items: Product[];
+    pagination: OffsetPagination;
+}
+export interface PlanFeature {
+    feature: ObjectIdentity;
+    name: string;
+}
+export interface Plan {
+    /** False once archived. An archived plan cannot be bought until it is active again. */
+    active: boolean;
+    lookup_key?: string;
+    product: Product;
+    features: PlanFeature[];
+    id: string;
+    product_id: ProductID;
+    name: string;
+    description?: string;
+}
+export interface PlanList {
+    items: Plan[];
+    pagination: OffsetPagination;
+}
+/**
+ * `postpaid` charges for what is used, `prepaid` buys a period in advance, `one_time`
+ * charges once.
+ */
+export type PriceType = (typeof PriceType)[keyof typeof PriceType];
+export declare const PriceType: {
+    readonly postpaid: "postpaid";
+    readonly prepaid: "prepaid";
+    readonly one_time: "one_time";
+};
+/**
+ * How the amount is arrived at. `rated` means the rate depends on attributes such as
+ * region or machine type, and is looked up on a price list.
+ */
+export type PriceBillingScheme = (typeof PriceBillingScheme)[keyof typeof PriceBillingScheme];
+export declare const PriceBillingScheme: {
+    readonly per_unit: "per_unit";
+    readonly tiered: "tiered";
+    readonly rated: "rated";
+};
+/**
+ * `none` for a price that is not tiered, which is most of them.
+ *
+ * Otherwise `graduated` charges each band at its own rate, and `volume` charges
+ * everything at the rate of the band the total falls in.
+ */
+export type PriceTiersMode = (typeof PriceTiersMode)[keyof typeof PriceTiersMode];
+export declare const PriceTiersMode: {
+    readonly none: "none";
+    readonly graduated: "graduated";
+    readonly volume: "volume";
+};
+export type PriceInterval = (typeof PriceInterval)[keyof typeof PriceInterval];
+export declare const PriceInterval: {
+    readonly none: "none";
+    readonly day: "day";
+    readonly month: "month";
+    readonly year: "year";
+};
+export interface Tier {
+    /**
+     * The upper bound of this band. Null on the last band, which has no bound.
+     * @nullable
+     */
+    up_to?: string | null;
+    unit_amount: Money;
+    /** Charged once when this band is reached, in addition to the per-unit amount. */
+    flat_amount?: Money;
+}
+export interface Price {
+    rate_card?: ObjectIdentity;
+    lookup_key?: string;
+    product: Product;
+    plan: ObjectIdentity;
+    meter_id?: string;
+    meter?: ObjectIdentity;
+    unit_quantity: string;
+    /** False once archived. An archived price cannot be bought until it is active again. */
+    active: boolean;
+    termination_policy?: TerminationPolicy;
+    refund_policy?: RefundPolicy;
+    product_id?: ProductID;
+    id: string;
+    plan_id: string;
+    currency: string;
+    /**
+     * `postpaid` charges for what is used, `prepaid` buys a period in advance, `one_time`
+     * charges once.
+     */
+    type: PriceType;
+    /**
+     * How the amount is arrived at. `rated` means the rate depends on attributes such as
+     * region or machine type, and is looked up on a price list.
+     */
+    billing_scheme: PriceBillingScheme;
+    /** Present for `per_unit`. */
+    unit_amount?: Money;
+    /**
+     * `none` for a price that is not tiered, which is most of them.
+     *
+     * Otherwise `graduated` charges each band at its own rate, and `volume` charges
+     * everything at the rate of the band the total falls in.
+     */
+    tiers_mode?: PriceTiersMode;
+    /** Present for `tiered`, in ascending order. */
+    tiers?: Tier[];
+    /** For `rated` prices, the price list the rates are read from. */
+    rate_card_id?: string;
+    /** The smallest quantity that can be bought. Absent means no lower bound. */
+    min_quantity?: string;
+    /**
+     * The largest purchasable quantity. Omitted when no maximum applies. A quantity above this limit is
+     * rejected with BILLING_PRICE_INVALID and field=max_quantity.
+     */
+    max_quantity?: string;
+    /** Quantities must be a multiple of this. Absent means any quantity within the bounds. */
+    quantity_step?: string;
+    /** For prepaid prices, how many periods one purchase covers. */
+    interval_count?: number;
+    interval: PriceInterval;
+    setup_fee?: Money;
+}
+export interface PriceList {
+    items: Price[];
+    pagination: OffsetPagination;
+}
+/**
+ * The attributes this rate applies to, such as region and machine type.
+ */
+export type RateDimensions = {
+    [key: string]: string;
+};
+/**
+ * `per_unit` multiplies `unit_amount`; `tiered` walks the tiers as `tiers_mode` says.
+ */
+export type RateBillingScheme = (typeof RateBillingScheme)[keyof typeof RateBillingScheme];
+export declare const RateBillingScheme: {
+    readonly per_unit: "per_unit";
+    readonly tiered: "tiered";
+};
+/**
+ * `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 arrive in, such as `core-second`. */
+    unit?: string;
+    /** The attributes this rate applies to, such as region and machine type. */
+    dimensions: RateDimensions;
+    /** `per_unit` multiplies `unit_amount`; `tiered` walks the tiers as `tiers_mode` says. */
+    billing_scheme: RateBillingScheme;
+    /** `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;
+}
+/**
+ * Narrows the selection when a plan offers more than one charge type.
+ */
+export type QuoteItemInputPriceType = (typeof QuoteItemInputPriceType)[keyof typeof QuoteItemInputPriceType];
+export declare const QuoteItemInputPriceType: {
+    readonly postpaid: "postpaid";
+    readonly prepaid: "prepaid";
+    readonly one_time: "one_time";
+};
+export type QuoteItemInputInterval = (typeof QuoteItemInputInterval)[keyof typeof QuoteItemInputInterval];
+export declare const QuoteItemInputInterval: {
+    readonly none: "none";
+    readonly day: "day";
+    readonly month: "month";
+    readonly year: "year";
+};
+/**
+ * The attributes the price depends on — region, instance type, token class.
+ *
+ * Required when the price draws its rates from a price list, which is how anything
+ * sold by region or by machine type is priced. A price that carries a single unit
+ * amount, or a ladder, has no attributes to give and takes none.
+ *
+ * Every attribute the meter declares must be present. A combination with no rate
+ * covering it is refused rather than priced at zero.
+ */
+export type QuoteItemInputDimensions = {
+    [key: string]: string;
+};
+/**
+ * Identify a price directly, or select a price for a plan. For each resource give its ID or lookup
+ * key, never both. Lookup keys require product_id. Meter, dimensions or duration_seconds request a
+ * postpaid usage estimate. Such an estimate cannot be combined with a promotion code or treated as a
+ * checkout amount. Without a usage estimate, a postpaid item includes only any setup charge.
+ */
+export interface QuoteItemInput {
+    /**
+     * @minLength 1
+     * @maxLength 128
+     */
+    price_lookup_key?: string;
+    /**
+     * @minLength 1
+     * @maxLength 128
+     */
+    plan_lookup_key?: string;
+    price_id?: string;
+    product_id?: ProductID;
+    plan_id?: string;
+    /** Narrows the selection when a plan offers more than one charge type. */
+    price_type?: QuoteItemInputPriceType;
+    interval?: QuoteItemInputInterval;
+    /** @minimum 1 */
+    interval_count?: number;
+    /** Selects among prepaid prices with otherwise identical billing terms. Ambiguous terms are refused instead of choosing a price arbitrarily. */
+    termination_policy?: TerminationPolicy;
+    /** @pattern ^(?:(?:[1-9][0-9]{0,27}|0(?:[1-9][0-9]{0,26}|0(?:[1-9][0-9]{0,25}|0(?:[1-9][0-9]{0,24}|0(?:[1-9][0-9]{0,23}|0(?:[1-9][0-9]{0,22}|0(?:[1-9][0-9]{0,21}|0(?:[1-9][0-9]{0,20}|0(?:[1-9][0-9]{0,19}|0(?:[1-9][0-9]{0,18}|0(?:[1-9][0-9]{0,17}|0(?:[1-9][0-9]{0,16}|0(?:[1-9][0-9]{0,15}|0(?:[1-9][0-9]{0,14}|0(?:[1-9][0-9]{0,13}|0(?:[1-9][0-9]{0,12}|0(?:[1-9][0-9]{0,11}|0(?:[1-9][0-9]{0,10}|0(?:[1-9][0-9]{0,9}|0(?:[1-9][0-9]{0,8}|0(?:[1-9][0-9]{0,7}|0(?:[1-9][0-9]{0,6}|0(?:[1-9][0-9]{0,5}|0(?:[1-9][0-9]{0,4}|0(?:[1-9][0-9]{0,3}|0(?:[1-9][0-9]{0,2}|0(?:[1-9][0-9]{0,1}|0[1-9])))))))))))))))))))))))))))([.][0-9]{1,10})?|0{1,28}[.](?:[1-9][0-9]{0,9}|0(?:[1-9][0-9]{0,8}|0(?:[1-9][0-9]{0,7}|0(?:[1-9][0-9]{0,6}|0(?:[1-9][0-9]{0,5}|0(?:[1-9][0-9]{0,4}|0(?:[1-9][0-9]{0,3}|0(?:[1-9][0-9]{0,2}|0(?:[1-9][0-9]{0,1}|0[1-9]))))))))))$ */
+    quantity: string;
+    meter_id?: string;
+    /**
+     * @minLength 1
+     * @maxLength 128
+     */
+    meter_lookup_key?: string;
+    /**
+     * The attributes the price depends on — region, instance type, token class.
+     *
+     * Required when the price draws its rates from a price list, which is how anything
+     * sold by region or by machine type is priced. A price that carries a single unit
+     * amount, or a ladder, has no attributes to give and takes none.
+     *
+     * Every attribute the meter declares must be present. A combination with no rate
+     * covering it is refused rather than priced at zero.
+     */
+    dimensions?: QuoteItemInputDimensions;
+    /**
+     * For metered items, how long to price for. This allows an estimate such as "about
+     * this much per month" to be shown before anything exists. The priced quantity is
+     * `quantity` multiplied by this duration.
+     */
+    duration_seconds?: number;
+}
+export interface SpendRow {
+    product?: Product;
+    plan_id?: string;
+    plan_name?: string;
+    /** Present only when grouped by resource. */
+    resource_id?: string;
+    amount: Money;
+    currency: string;
+}
+export interface SpendRowList {
+    items: SpendRow[];
+    /** The sum over the whole period, not only the page returned. */
+    total: Money;
+    currency: string;
+    pagination: OffsetPagination;
+}
+export type ActiveResourceDimensions = {
+    [key: string]: string;
+};
+export type ActiveResourceStatus = (typeof ActiveResourceStatus)[keyof typeof ActiveResourceStatus];
+export declare const ActiveResourceStatus: {
+    readonly active: "active";
+    readonly suspended: "suspended";
+    readonly closing: "closing";
+    readonly closed: "closed";
+};
+/**
+ * A resource currently accruing charges by the second.
+ */
+export interface ActiveResource {
+    id: string;
+    ended_at?: string;
+    suspended_at?: string;
+    state_changed_at?: string;
+    /** The postpaid subscription charged for this metering record, including shared services. */
+    subscription_id: string;
+    resource_id: string;
+    product: Product;
+    /** What it is, as its own service names it. */
+    resource_type?: string;
+    meter: ObjectIdentity;
+    unit?: string;
+    /** How much is held — cores, MiB, cards. Not how much has been used. */
+    quantity: string;
+    dimensions?: ActiveResourceDimensions;
+    status: ActiveResourceStatus;
+    started_at: string;
+    project_id?: string;
+    /** Usage has been generated up to this boundary; it does not imply invoicing or payment. */
+    usage_generated_until: string;
+}
+export interface ActiveResourceList {
+    items: ActiveResource[];
+    pagination: OffsetPagination;
+}
+/**
+ * An estimate of the refundable value of one order or selected items. This does not cancel the order, stop service or create a refund.
+ */
+export interface OrderRefundQuoteInput {
+    order_id: string;
+    /**
+     * Estimate only these items. Omit to estimate the whole order. Every item must belong to the order.
+     * @minItems 1
+     * @maxItems 100
+     */
+    order_item_ids?: string[];
+}
+/**
+ * "Quote exactly one target: proposed items, an existing order, renewals, a cancellation or an order
+ * refund. All targets use the specified billing account. Nothing is saved, charged, reserved or
+ * canceled. Promotion codes apply only to a purchase basket or an existing order. An invalid
+ * combination returns BILLING_PURCHASE_INVALID with the offending field."
+ */
+export interface QuoteRequest {
+    /**
+     * The billing account to price for. It must belong to you. Existing orders must have been purchased
+     * with this account; renewals and cancellations must currently be paid for by it.
+     * @minimum 1
+     */
+    billing_account_id: number;
+    /**
+     * A proposed purchase priced in the account currency. Metered items may estimate specified usage
+     * quantities; those estimates are not amounts collectible at checkout.
+     * @minItems 1
+     * @maxItems 100
+     */
+    items?: QuoteItemInput[];
+    /**
+     * Preview paying this existing order. Its recorded purchase terms supply every line, and an order
+     * whose terms are fixed returns its recorded amounts. A preview does not change the order.
+     */
+    order_id?: string;
+    /**
+     * Preview renewing these subscriptions, each at most once. Each entry represents a separate
+     * renewal order. To preview a new promotion code, create a renewal order and quote it by order_id.
+     * @minItems 1
+     * @maxItems 100
+     */
+    renewals?: QuoteRenewal[];
+    cancellation?: QuoteCancellation;
+    /**
+     * @minLength 1
+     * @maxLength 64
+     */
+    promotion_code?: string;
+    refund?: OrderRefundQuoteInput;
+}
+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;
+}
+export type StatementStatus = (typeof StatementStatus)[keyof typeof StatementStatus];
+export declare const StatementStatus: {
+    readonly open: "open";
+    readonly closed: "closed";
+};
+/**
+ * An account's consumption for one billing period, collected at one closing. The first statement of a period (sequence 1) closes after the period ends. Usage priced after that closing is collected in a later statement for the same period, which closes and invoices separately; a closed statement is never rewritten. Payments apply to issued invoices.
+ */
+export interface Statement {
+    id: string;
+    billing_account_id: number;
+    currency: string;
+    period_start: string;
+    period_end: string;
+    /** 1 for the first closing of the period; higher for statements that collect usage priced after an earlier closing. */
+    sequence: number;
+    status: StatementStatus;
+    /** True while the statement is open. The estimate applies tier pricing to the period's usage so far and adds tax for the current invoice contact. Minimum charges are added at closing, and a tier reduction larger than this statement's own charges is credited to earlier invoices of the period 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;
+}
+export interface StatementItem {
+    project_id?: string;
+    product_id?: string;
+    meter_id?: string;
+    unit?: string;
+    /** 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;
+}
 /**
  * The request conflicts with the current state of the service. The codes are described where they apply.
  */