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

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

@@ -0,0 +1,3683 @@
+/**
+ * Generated by orval 🍺
+ * Do not edit manually.
+ * Leaflow Canopy API
+ * Canopy model inference, API keys, model catalogue, service enablement and recorded usage.
+ *
+ * OpenAI-compatible project inference is served on this host at `/v1/chat/completions`,
+ * `/v1/embeddings`, `/v1/models` and `/v1/models/{model}`. Use `https://canopy.leaflow.cloud/v1`
+ * as the OpenAI SDK base URL. Chat completions support `stream=true` SSE.
+ *
+ * Management operations use `/api/v1`. The management model catalogue includes pricing;
+ * `/v1/models` returns the OpenAI model format with Canopy capabilities and parameter limits.
+ *
+ * ## Authentication
+ *
+ * Every request carries a scoped token; see the `bearerAuth` security scheme.
+ *
+ * Management and project inference accept the same verified IAM scoped token. The token is the
+ * sole billing project authority; `OpenAI-Project` and historical identity headers cannot
+ * override it. These endpoints do not accept a Canopy API key. The separate API-key gateway
+ * accepts Canopy API keys and supports OpenAI, Anthropic and Gemini request formats.
+ *
+ * ## Conventions
+ *
+ * - **The plaintext of an API key is returned once.** The `secret` appears in the response that issues it and is returned by no other endpoint. A key that has been lost has to be revoked and reissued.
+ * - **Disabling and revoking are distinct.** A disabled key may be enabled again at any time, while a revocation is irreversible and is intended for a key that has been exposed. Neither removes the record, and the usage the key accrued remains readable.
+ * - **A usage query must carry a time range**, spanning no more than 31 days. `from` and `to` carry a timezone offset, which the server does not infer.
+ * - **The request and response bodies do not appear in the ledger.** They are not recorded. Quote the `upstream_request_id` from the response when reporting a problem.
+ * - **Usage may be estimated.** The upstream provider does not report usage on every request. Where it does not, `usage_source` is `estimated` and the figures are derived from the character classes of the payload, to within roughly fifteen per cent.
+ * - **The service is enabled before use.** A project enables the model platform once, through `create-service`; the forwarding endpoints refuse its requests until the service is `active`. Requests are then billed under the service's subscription by the tokens they use, at the rates stated in each model's `pricing`.
+ * OpenAPI spec version: 1.0.0
+ */
+export type ReasoningDiagnosticsRequested = {
+    [key: string]: unknown;
+};
+export type ReasoningDiagnosticsEffective = {
+    [key: string]: unknown;
+};
+export type ReasoningDiagnosticsTranslation = (typeof ReasoningDiagnosticsTranslation)[keyof typeof ReasoningDiagnosticsTranslation];
+export declare const ReasoningDiagnosticsTranslation: {
+    readonly translate: "translate";
+    readonly passthrough: "passthrough";
+    readonly strip: "strip";
+};
+export interface ReasoningDiagnostics {
+    requested: ReasoningDiagnosticsRequested;
+    effective?: ReasoningDiagnosticsEffective;
+    translation?: ReasoningDiagnosticsTranslation;
+}
+export type ChatCompletionRequestMessagesItem = {
+    [key: string]: unknown;
+};
+export interface ChatCompletionRequest {
+    /** @minLength 1 */
+    model: string;
+    /** @minItems 1 */
+    messages: ChatCompletionRequestMessagesItem[];
+    stream?: boolean;
+    /** @minimum 1 */
+    max_tokens?: number;
+    /** @minimum 1 */
+    max_completion_tokens?: number;
+    reasoning_effort?: string;
+    [key: string]: unknown;
+}
+export interface ChatCompletion {
+    [key: string]: unknown;
+}
+export type EmbeddingRequestEncodingFormat = (typeof EmbeddingRequestEncodingFormat)[keyof typeof EmbeddingRequestEncodingFormat];
+export declare const EmbeddingRequestEncodingFormat: {
+    readonly float: "float";
+    readonly base64: "base64";
+};
+export interface EmbeddingRequest {
+    /** @minLength 1 */
+    model: string;
+    /** A nonempty string, string array, token integer array, or array of token integer arrays. */
+    input: string | unknown[];
+    encoding_format?: EmbeddingRequestEncodingFormat;
+    /** @minimum 1 */
+    dimensions?: number;
+    user?: string;
+    [key: string]: unknown;
+}
+export interface EmbeddingResponse {
+    [key: string]: unknown;
+}
+export type Modality = (typeof Modality)[keyof typeof Modality];
+export declare const Modality: {
+    readonly text: "text";
+    readonly image: "image";
+    readonly audio: "audio";
+    readonly video: "video";
+    readonly file: "file";
+    readonly embedding: "embedding";
+};
+/**
+ * @nullable
+ */
+export type ReasoningCapabilitiesBudgetTokens = {
+    /** @minimum 0 */
+    min: number;
+    /** @minimum 0 */
+    max: number;
+} | null;
+export interface ReasoningCapabilities {
+    supported: boolean;
+    /**
+     * Null means unknown; an empty array means effort is not configurable.
+     * @nullable
+     */
+    effort_levels: string[] | null;
+    /** @nullable */
+    default_effort: string | null;
+    /** @nullable */
+    modes: string[] | null;
+    /** @nullable */
+    budget_tokens: ReasoningCapabilitiesBudgetTokens;
+    /** @nullable */
+    summary: string[] | null;
+}
+export interface EndpointCapabilities {
+    /** @nullable */
+    function_calling: boolean | null;
+    /** @nullable */
+    structured_output: boolean | null;
+    reasoning: ReasoningCapabilities | null;
+}
+/**
+ * Verified capabilities keyed by API endpoint, for example /v1/chat/completions or /v1/responses. Missing keys and null values mean unknown. Current route availability is separate.
+ */
+export interface ModelCapabilities {
+    [key: string]: EndpointCapabilities;
+}
+export type ModelEndpoint = (typeof ModelEndpoint)[keyof typeof ModelEndpoint];
+export declare const ModelEndpoint: {
+    readonly "/v1/chat/completions": "/v1/chat/completions";
+    readonly "/v1/responses": "/v1/responses";
+    readonly "/v1/embeddings": "/v1/embeddings";
+    readonly "/v1/images/generations": "/v1/images/generations";
+    readonly "/v1/images/edits": "/v1/images/edits";
+    readonly "/v1/audio/transcriptions": "/v1/audio/transcriptions";
+    readonly "/v1/audio/translations": "/v1/audio/translations";
+    readonly "/v1/audio/speech": "/v1/audio/speech";
+    readonly "/v1/realtime": "/v1/realtime";
+};
+export interface Model {
+    id: string;
+    object: "model";
+    created: number;
+    owned_by: string;
+    display_name: string;
+    context_length: number;
+    max_output_tokens: number;
+    /** The model developer; not the upstream provider or model family. */
+    developer: string;
+    description: string;
+    /**
+     * Accepted input modalities. Null means unknown.
+     * @nullable
+     */
+    input_modalities: Modality[] | null;
+    /**
+     * Produced output modalities. Image input does not imply image generation.
+     * @nullable
+     */
+    output_modalities: Modality[] | null;
+    capabilities: ModelCapabilities;
+    /** Explicitly supported API endpoints. Requests to any other endpoint are rejected before upstream admission. */
+    supported_endpoints: ModelEndpoint[];
+}
+export interface ModelList {
+    object: "list";
+    data: Model[];
+}
+export type InferenceErrorError = {
+    message: string;
+    type: string;
+    /** @nullable */
+    param?: string | null;
+    /** @nullable */
+    code?: string | null;
+    [key: string]: unknown;
+};
+export interface InferenceError {
+    error: InferenceErrorError;
+}
+/**
+ * What a given `code` carries alongside the message. The keys depend on the code,
+ * and a client that does not recognise one ignores it.
+ */
+export type ErrorMeta = {
+    [key: string]: unknown;
+};
+export interface Error {
+    code?: string;
+    message: string;
+    /**
+     * What a given `code` carries alongside the message. The keys depend on the code,
+     * and a client that does not recognise one ignores it.
+     */
+    meta?: ErrorMeta;
+    status: number;
+}
+export type APIKeyResourceStatus = (typeof APIKeyResourceStatus)[keyof typeof APIKeyResourceStatus];
+export declare const APIKeyResourceStatus: {
+    readonly active: "active";
+    readonly disabled: "disabled";
+    readonly revoked: "revoked";
+};
+export interface APIKeyResource {
+    /** Carries no meaning while `restrict_models` is false */
+    allowed_models: string[];
+    created_at: string;
+    /** Who created the key */
+    created_by: string;
+    /**
+     * When the key expires. Null means it never expires
+     * @nullable
+     */
+    expires_at: string | null;
+    id: string;
+    /** The last four characters of the plaintext */
+    last_four: string;
+    /**
+     * When the key was last used to forward a request successfully, accurate to about a minute
+     * @nullable
+     */
+    last_used_at: string | null;
+    name: string;
+    /** The leading characters of the plaintext, by which a key is recognised in a list */
+    prefix: string;
+    /** While true, only the models listed in `allowed_models` are permitted */
+    restrict_models: boolean;
+    status: APIKeyResourceStatus;
+    /** True indicates that the key was disabled because its project is suspended, and that the project has to be restored before the key can be used again */
+    suspended: boolean;
+}
+export interface LengthAwarePageAPIKeyResource {
+    /** The items in this page */
+    items: APIKeyResource[];
+    /** Maximum number of items in this page, echoing the request */
+    limit: number;
+    /** Number of items skipped, echoing the request */
+    offset: number;
+    /** Total number of matches, not only this page */
+    total: number;
+}
+export interface CreateAPIKeyRequestBody {
+    /**
+     * Ignored while `restrict_models` is false
+     * @nullable
+     */
+    allowed_models?: string[] | null;
+    /**
+     * When the key expires. Omitted means it never expires
+     * @nullable
+     */
+    expires_at?: string | null;
+    /**
+     * A name for the holder's own use, such as CI or Production
+     * @minLength 1
+     * @maxLength 128
+     */
+    name: string;
+    /** While true, only the models listed in `allowed_models` are permitted */
+    restrict_models?: boolean;
+}
+export type IssuedAPIKeyResourceStatus = (typeof IssuedAPIKeyResourceStatus)[keyof typeof IssuedAPIKeyResourceStatus];
+export declare const IssuedAPIKeyResourceStatus: {
+    readonly active: "active";
+    readonly disabled: "disabled";
+    readonly revoked: "revoked";
+};
+export interface IssuedAPIKeyResource {
+    /** Carries no meaning while `restrict_models` is false */
+    allowed_models: string[];
+    created_at: string;
+    /** Who created the key */
+    created_by: string;
+    /**
+     * When the key expires. Null means it never expires
+     * @nullable
+     */
+    expires_at: string | null;
+    id: string;
+    /** The last four characters of the plaintext */
+    last_four: string;
+    /**
+     * When the key was last used to forward a request successfully, accurate to about a minute
+     * @nullable
+     */
+    last_used_at: string | null;
+    name: string;
+    /** The leading characters of the plaintext, by which a key is recognised in a list */
+    prefix: string;
+    /** While true, only the models listed in `allowed_models` are permitted */
+    restrict_models: boolean;
+    /** The complete key, **returned in this response only**. Store it immediately */
+    secret: string;
+    status: IssuedAPIKeyResourceStatus;
+    /** True indicates that the key was disabled because its project is suspended, and that the project has to be restored before the key can be used again */
+    suspended: boolean;
+}
+export interface UpdateAPIKeyRequestBody {
+    /** @nullable */
+    allowed_models?: string[] | null;
+    /** True removes the expiry */
+    clear_expiry?: boolean;
+    /**
+     * Sets the expiry. To remove it, use `clear_expiry`
+     * @nullable
+     */
+    expires_at?: string | null;
+    /**
+     * @maxLength 128
+     * @nullable
+     */
+    name?: string | null;
+    /** @nullable */
+    restrict_models?: boolean | null;
+}
+export type ModelResourceStatus = (typeof ModelResourceStatus)[keyof typeof ModelResourceStatus];
+export declare const ModelResourceStatus: {
+    readonly available: "available";
+    readonly draining: "draining";
+    readonly retired: "retired";
+};
+export type TokenPriceTokenKind = (typeof TokenPriceTokenKind)[keyof typeof TokenPriceTokenKind];
+export declare const TokenPriceTokenKind: {
+    readonly input: "input";
+    readonly output: "output";
+    readonly cache_read: "cache_read";
+    readonly cache_write: "cache_write";
+    readonly reasoning: "reasoning";
+};
+/**
+ * A decimal string, in the currency stated alongside it.
+ *
+ * **The currency is not part of this type.** It is carried by a `currency` field next to the
+ * amount, or by the account the amount belongs to. Reading an amount without that field is
+ * reading a number with no unit.
+ *
+ * It is a string rather than a JSON number because a JSON number is a float in most parsers,
+ * and a float loses precision on the first arithmetic. Nothing on this platform puts an amount
+ * through a float.
+ */
+export type Money = string;
+export interface TokenPrice {
+    token_kind: TokenPriceTokenKind;
+    /** The charge for `unit_quantity` tokens of this kind. Null when the kind has no rate in the currency, in which case the model cannot be billed for it. */
+    unit_amount: Money | null;
+    /**
+     * How many tokens `unit_amount` is for, such as `1000000`. Null when `unit_amount` is null.
+     * @nullable
+     */
+    unit_quantity: string | null;
+}
+/**
+ * What requests to a model cost, as Billing prices them in the currency of the project's current billing account. These are list amounts before promotion codes, not a checkout guarantee; usage is billed afterwards under the service's subscription.
+ *
+ * Each token kind is priced on its own. `input` excludes cached input, which is `cache_read`, and `output` excludes reasoning the provider reports separately, which is `reasoning`; a request is billed for each kind it used.
+ */
+export interface ModelPricing {
+    currency: string;
+    /** One entry for each of the five token kinds, in the order input, output, cache_read, cache_write, reasoning. */
+    token_kinds: TokenPrice[];
+}
+export interface ModelResource {
+    /** The context window. Advisory only; the server does not truncate on its basis */
+    context_length: number;
+    display_name: string;
+    /** Groups the models of one family together, such as claude, gpt or gemini */
+    family: string;
+    /** The string to send in the `model` field of the request body */
+    id: string;
+    /** The maximum output length. Advisory only */
+    max_output_tokens: number;
+    /** What requests to this model cost. Null when the project has no billing account. */
+    pricing: ModelPricing | null;
+    status: ModelResourceStatus;
+    /** The model developer; not the upstream provider or model family. */
+    developer: string;
+    description: string;
+    /**
+     * Accepted input modalities. Null means unknown.
+     * @nullable
+     */
+    input_modalities: Modality[] | null;
+    /**
+     * Produced output modalities. Image input does not imply image generation.
+     * @nullable
+     */
+    output_modalities: Modality[] | null;
+    capabilities: ModelCapabilities;
+    /** Explicitly supported API endpoints. Requests to any other endpoint are rejected before upstream admission. */
+    supported_endpoints: ModelEndpoint[];
+}
+export interface ModelListResponseBody {
+    items: ModelResource[];
+}
+export type RequestResourceStatus = (typeof RequestResourceStatus)[keyof typeof RequestResourceStatus];
+export declare const RequestResourceStatus: {
+    readonly in_flight: "in_flight";
+    readonly succeeded: "succeeded";
+    readonly refused: "refused";
+    readonly upstream_failed: "upstream_failed";
+    readonly client_aborted: "client_aborted";
+};
+/**
+ * upstream means the figures were reported by the provider; estimated means they were derived from the character classes of the payload
+ */
+export type RequestResourceUsageSource = (typeof RequestResourceUsageSource)[keyof typeof RequestResourceUsageSource];
+export declare const RequestResourceUsageSource: {
+    readonly none: "none";
+    readonly upstream: "upstream";
+    readonly estimated: "estimated";
+};
+export interface RequestResource {
+    /**
+     * Null for a request made by an internal service directly for the project.
+     * @nullable
+     */
+    api_key_id: string | null;
+    /** The portion served from the upstream prefix cache, which costs an order of magnitude less than ordinary input */
+    cache_read_tokens: number;
+    cache_write_tokens: number;
+    /** The error code on failure. Empty on success */
+    error_code: string;
+    /** @nullable */
+    finished_at: string | null;
+    /** @nullable */
+    first_token_at: string | null;
+    id: string;
+    input_tokens: number;
+    /** The model named in the request */
+    model_id: string;
+    output_tokens: number;
+    reasoning_tokens: number;
+    retries: number;
+    started_at: string;
+    status: RequestResourceStatus;
+    stream: boolean;
+    /** The id of the request on the upstream side. Quote it when reporting a problem */
+    upstream_request_id: string;
+    /** The HTTP status returned upstream. 0 indicates that the request never reached it */
+    upstream_status: number;
+    /** upstream means the figures were reported by the provider; estimated means they were derived from the character classes of the payload */
+    usage_source: RequestResourceUsageSource;
+    reasoning: ReasoningDiagnostics | null;
+}
+export interface CursorPageRequestResource {
+    /** The items in this page */
+    items: RequestResource[];
+    /** The cursor for the next page. Empty on the last page */
+    next_cursor: string;
+}
+export interface APIKeyUsageResource {
+    api_key_id: string;
+    cache_read_tokens: number;
+    cache_write_tokens: number;
+    input_tokens: number;
+    output_tokens: number;
+    reasoning_tokens: number;
+    requests: number;
+}
+export interface APIKeyUsageListResponseBody {
+    items: APIKeyUsageResource[];
+}
+export interface ModelUsageResource {
+    cache_read_tokens: number;
+    cache_write_tokens: number;
+    input_tokens: number;
+    model_id: string;
+    output_tokens: number;
+    reasoning_tokens: number;
+    requests: number;
+}
+export interface ModelUsageListResponseBody {
+    items: ModelUsageResource[];
+}
+export interface TotalsResource {
+    cache_read_tokens: number;
+    cache_write_tokens: number;
+    input_tokens: number;
+    output_tokens: number;
+    reasoning_tokens: number;
+    requests: number;
+}
+export interface UsageBucketResource {
+    cache_read_tokens: number;
+    cache_write_tokens: number;
+    /** Start of the bucket, inclusive */
+    from: string;
+    input_tokens: number;
+    output_tokens: number;
+    reasoning_tokens: number;
+    requests: number;
+    /** End of the bucket, exclusive */
+    to: string;
+}
+export interface UsageTimelineResponseBody {
+    items: UsageBucketResource[];
+}
+/**
+ * `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.
+ */
+export type ServiceResourceStatus = (typeof ServiceResourceStatus)[keyof typeof ServiceResourceStatus];
+export declare const ServiceResourceStatus: {
+    readonly inactive: "inactive";
+    readonly pending: "pending";
+    readonly active: "active";
+    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 it was not paid in time.
+ * @nullable
+ */
+export type ServiceResourceFailureReason = (typeof ServiceResourceFailureReason)[keyof typeof ServiceResourceFailureReason] | null;
+export declare const ServiceResourceFailureReason: {
+    readonly order_declined: "order_declined";
+    readonly order_canceled: "order_canceled";
+    readonly order_expired: "order_expired";
+};
+/**
+ * The model platform service of a project.
+ */
+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 it was not paid in time.
+     * @nullable
+     */
+    failure_reason: ServiceResourceFailureReason;
+    /**
+     * The order that enabled the service, or that the latest enablement placed; null before any enablement.
+     * @nullable
+     */
+    order_id: string | null;
+    /**
+     * The Billing subscription that requests are billed under; null before any enablement.
+     * @nullable
+     */
+    subscription_id: string | null;
+    /**
+     * When the service became active and billing began; null until then.
+     * @nullable
+     */
+    activated_at: string | null;
+    /**
+     * When the subscription ended; null unless it has.
+     * @nullable
+     */
+    ended_at: string | null;
+}
+/**
+ * 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 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: {
+    readonly automatic: "automatic";
+    readonly deferred: "deferred";
+};
+/**
+ * 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 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 {
+    mode?: CheckoutMode;
+    /**
+     * Expected invoice total after discounts and tax, before applying credit grants or balance.
+     * A different total fails with BILLING_AMOUNT_CHANGED without charging or reserving a discount.
+     * Accepted only in automatic mode; with deferred it is refused with HTTP 400. For deferred
+     * checkout, give the expected amount when paying the invoice through Billing.
+     */
+    expected_amount?: Money & string;
+}
+export interface CreateServiceRequestBody {
+    checkout?: CheckoutOptions;
+}
+/**
+ * `draft`: not yet issued; an order's draft invoice shows base prices until it is paid, when the discount is applied and it is issued. Other drafts are visible only to operators. `open`: issued and not yet settled; a zero-total invoice is paid at once. `paid` stays paid after a refund, with the refunded part in amount_refunded. `void`: collection has stopped and any funds received have been returned. Usage not yet invoiced is not on any invoice.
+ */
+export type InvoiceStatus = (typeof InvoiceStatus)[keyof typeof InvoiceStatus];
+export declare const InvoiceStatus: {
+    readonly draft: "draft";
+    readonly open: "open";
+    readonly paid: "paid";
+    readonly void: "void";
+};
+/**
+ * An order's invoice amounts, without contact details or payment methods. A draft shows base prices until it is paid, when the discount is applied and it is issued; a zero-total invoice is issued and paid at placement.
+ */
+export interface InvoiceSummary {
+    id: string;
+    number?: string;
+    currency: string;
+    status: InvoiceStatus;
+    /**
+     * Sum of the line amounts before discounts. Where prices include tax, the tax contained in
+     * each line's discounted amount is taken out here, so that total = subtotal -
+     * discount_amount + tax_amount always holds.
+     */
+    subtotal: string;
+    /** Sum of the line discounts, taken off before tax. */
+    discount_amount: string;
+    tax_amount: string;
+    total: string;
+    amount_paid: string;
+    /** Issued credit notes that reduced unpaid receivables; the original invoice total is unchanged. */
+    pre_payment_credit_notes_amount: Money;
+    /** Issued credit notes against payments already received; their refunds may not have completed. */
+    post_payment_credit_notes_amount: Money;
+    /**
+     * What is still collectible after unpaid credit notes and successful payments; never below zero.
+     * @pattern ^\d+(\.\d{1,10})?$
+     */
+    amount_due: string;
+    amount_refunded: string;
+    due_at?: string;
+}
+/**
+ * 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.
+ */
+export interface CreateServiceResponseBody {
+    service: ServiceResource;
+    order: PlacedOrder;
+}
+/**
+ * Account funding for this purchase, calculated by Billing. Amounts use the enclosing response currency.
+ * Credit eligibility and all purchase requirements are already evaluated. Nothing is charged or reserved.
+ * A licensed purchase may instead be paid with an online payment method.
+ */
+export interface Funds {
+    /** Spendable balance after pending returns. */
+    available_balance_amount: Money;
+    /** Currently effective credits eligible for the quoted purchases or metered usage. Each grant is counted once. */
+    usable_credit_amount: Money;
+    /** Currently effective credits that cannot fund any quoted purchase or metered target. Unused eligible credits are not restricted. */
+    restricted_credit_amount: Money;
+    /** Minimum spendable balance needed after eligible credits, covering immediate charges and every new metered purchase's admission requirement. */
+    required_balance_amount: Money;
+    /** Additional balance needed now. Zero means account funds satisfy this quote. No funds are reserved. */
+    balance_shortfall_amount: Money;
+    /** Minimum recharge that covers the shortfall, respecting the currency minimum recharge and currency precision. Zero when no additional balance is needed. */
+    required_top_up_amount: Money;
+}
+/**
+ * One calculated purchase line. Fixed purchase amounts are rounded as checkout rounds them.
+ * 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 QuoteItemDc1fddb {
+    plan_name: string;
+    /**
+     * Unit price before discounts, with tax included only where the price includes it. Null when
+     * no single unit price applies, such as tiered or multiple-rate pricing or an immediate change.
+     */
+    unit_amount: Money | null;
+    /** The quantity priced. */
+    quantity: string;
+    /**
+     * Before discounts, including any setup charges. Contains tax only where the price includes it.
+     * Zero for an item with no immediate charge.
+     */
+    amount: Money;
+    /** Total reduction on this line, including any committed recurring discount. */
+    discount_amount: Money;
+    /** Tax on the discounted amount, including any tax already contained in that amount. */
+    tax_amount: Money;
+    /** The part of tax_amount already contained in amount minus discount_amount. */
+    tax_included_amount: Money;
+    /** amount minus discount_amount plus tax_amount minus tax_included_amount. */
+    total: Money;
+    /**
+     * Projected charge for this line's future usage over the period stated by the quoting operation,
+     * at current rates, before discounts and tax and not rounded. Not part of amount or total and
+     * not collected at checkout. Null when no usage estimate is requested for this line.
+     */
+    estimated_usage_amount: Money | null;
+    currency: string;
+}
+/**
+ * A price preview for the purchase described by a service, calculated by Billing. Nothing is saved,
+ * charged or reserved, and no discount redemption is consumed. Account discounts and tax are
+ * evaluated as for automatic checkout. Promotion codes are evaluated through Billing quote operations.
+ * All amounts use currency. This preview does not lock prices or guarantee discount availability.
+ * Success includes complete checkout amounts and every requested usage estimate. If any item or
+ * requested usage estimate cannot be calculated, the operation returns its existing structured
+ * error response; it never returns a partial quote with HTTP 200.
+ */
+export interface Quote {
+    funds: Funds;
+    /** One line for each item the purchase would order, in the order it would order them. */
+    items: QuoteItemDc1fddb[];
+    /**
+     * Sum of line amounts before discounts, less tax already included in the discounted line
+     * amounts, as on an invoice.
+     */
+    subtotal: Money;
+    /** Sum of line discounts. */
+    discount_amount: Money;
+    /** Sum of tax on the discounted line amounts. */
+    tax_amount: Money;
+    /**
+     * subtotal minus discount_amount plus tax_amount: what checkout collects, before applying
+     * credit grants or balance. Equals the sum of line totals and excludes estimated_usage_amount.
+     */
+    total: Money;
+    /**
+     * Sum of the lines' estimated_usage_amount. A projection, not part of total and not collected at
+     * checkout. Null when no usage estimate is requested.
+     */
+    estimated_usage_amount: Money | null;
+    currency: string;
+    /**
+     * Changes only; null otherwise. The instant the change is priced from. Pass it with the change so the
+     * order is priced from the same instant.
+     * @nullable
+     */
+    proration_date: string | null;
+    /**
+     * Changes that lower the price only; null otherwise. What the change would return to the original
+     * payment sources, including the tax paid on it. total is zero for such a change.
+     */
+    refundable_amount: Money | null;
+}
+export type ResponseCreateReasoning = {
+    [key: string]: unknown;
+};
+export type ResponseCreateToolsItem = {
+    [key: string]: unknown;
+};
+/**
+ * Native Responses request. model may be omitted when continuing a project-owned stored response. store defaults to false. Only caller-executed function and custom tools are supported. background, conversation and WebSocket-only fields are rejected over HTTP.
+ */
+export interface ResponseCreate {
+    model?: string;
+    input?: unknown;
+    /** @nullable */
+    instructions?: string | null;
+    store?: boolean;
+    stream?: boolean;
+    /** @nullable */
+    previous_response_id?: string | null;
+    reasoning?: ResponseCreateReasoning;
+    tools?: ResponseCreateToolsItem[];
+    /** @minimum 1 */
+    max_output_tokens?: number;
+    [key: string]: unknown;
+}
+export interface ResponseResource {
+    [key: string]: unknown;
+}
+export interface ResponseDeleted {
+    id: string;
+    object: string;
+    deleted: boolean;
+}
+/**
+ * Pagination metadata for stable numbered pages. total_count is returned only when the operation can determine it without an unbounded scan.
+ */
+export interface OffsetPagination {
+    /** @minimum 1 */
+    page: number;
+    /** @minimum 1 */
+    page_size: number;
+    /** @minimum 0 */
+    total_count?: number;
+}
+/**
+ * Pagination metadata for keyset traversal. Pass next_cursor as cursor to read the following page; null means there is no following page.
+ */
+export interface CursorPagination {
+    /** @minimum 1 */
+    page_size: number;
+    /** @nullable */
+    next_cursor?: string | null;
+}
+export interface WithdrawalAllocation {
+    source_transaction_id: string;
+    /** @pattern ^[0-9]{1,15}([.][0-9]{1,10})?$ */
+    amount: string;
+    /** @pattern ^[0-9]{1,15}([.][0-9]{1,10})?$ */
+    fee_amount: string;
+    /** @pattern ^[0-9]{1,15}([.][0-9]{1,10})?$ */
+    refund_amount: string;
+}
+export type WithdrawalItemStatus = (typeof WithdrawalItemStatus)[keyof typeof WithdrawalItemStatus];
+export declare const WithdrawalItemStatus: {
+    readonly pending: "pending";
+    readonly succeeded: "succeeded";
+    readonly failed: "failed";
+    readonly reversed: "reversed";
+};
+/**
+ * The original top-up and where its refund goes. Card details are included when the original payment method was saved.
+ */
+export interface WithdrawalSource {
+    /** @pattern ^[0-9]{1,15}([.][0-9]{1,10})?$ */
+    amount: string;
+    /**
+     * @minLength 3
+     * @maxLength 3
+     */
+    currency: string;
+    received_at: string;
+    payment_gateway: string;
+    method_type: string;
+    card_brand?: string;
+    /** @pattern ^[0-9]{4}$ */
+    card_last4?: string;
+}
+/**
+ * For one original top-up: the principal deducted, the withdrawal fee and the amount refunded, through its own refund. payment_gateway and method_type identify the original route.
+ */
+export interface WithdrawalItem {
+    source_transaction_id: string;
+    /** @pattern ^[0-9]{1,15}([.][0-9]{1,10})?$ */
+    amount: string;
+    /** @pattern ^[0-9]{1,15}([.][0-9]{1,10})?$ */
+    fee_amount: string;
+    /** @pattern ^[0-9]{1,15}([.][0-9]{1,10})?$ */
+    refund_amount: string;
+    id: string;
+    withdrawal_id: string;
+    billing_account_id: number;
+    /**
+     * @minLength 3
+     * @maxLength 3
+     */
+    currency: string;
+    refund_id: string;
+    fee_transaction_id?: string;
+    status: WithdrawalItemStatus;
+    completed_at?: string;
+    payment_gateway: string;
+    method_type: string;
+    source: WithdrawalSource;
+    /** The gateway's failure code when a refund failed, or `refund_reversed` when a completed refund was reversed. Absent while pending or successful. */
+    failure_code?: string;
+}
+export type WithdrawalStatus = (typeof WithdrawalStatus)[keyof typeof WithdrawalStatus];
+export declare const WithdrawalStatus: {
+    readonly pending: "pending";
+    readonly processing: "processing";
+    readonly succeeded: "succeeded";
+    readonly partially_completed: "partially_completed";
+    readonly failed: "failed";
+    readonly reversed: "reversed";
+};
+/**
+ * A withdrawal of account balance to the original payment methods of its unused top-ups. Accepted amounts are fixed. deducted_amount, settled_amount and charged_fee_amount cover completed items. A failed item releases its principal and fee; successful items stand when another item fails.
+ */
+export interface Withdrawal {
+    id: string;
+    billing_account_id: number;
+    /**
+     * @minLength 3
+     * @maxLength 3
+     */
+    currency: string;
+    /** @pattern ^[0-9]{1,15}([.][0-9]{1,10})?$ */
+    amount: string;
+    /** @pattern ^[0-9]{1,15}([.][0-9]{1,10})?$ */
+    fee_amount: string;
+    /** @pattern ^[0-9]{1,15}([.][0-9]{1,10})?$ */
+    refund_amount: string;
+    /** @pattern ^[0-9]{1,15}([.][0-9]{1,10})?$ */
+    deducted_amount: string;
+    /** @pattern ^[0-9]{1,15}([.][0-9]{1,10})?$ */
+    settled_amount: string;
+    /** @pattern ^[0-9]{1,15}([.][0-9]{1,10})?$ */
+    charged_fee_amount: string;
+    status: WithdrawalStatus;
+    created_at: string;
+    completed_at?: string;
+    /** Who submitted the withdrawal; may differ from the account owner. */
+    created_by?: string;
+}
+export interface WithdrawalPreviewItem {
+    source_transaction_id: string;
+    /** @pattern ^[0-9]{1,15}([.][0-9]{1,10})?$ */
+    amount: string;
+    /** @pattern ^[0-9]{1,15}([.][0-9]{1,10})?$ */
+    fee_amount: string;
+    /** @pattern ^[0-9]{1,15}([.][0-9]{1,10})?$ */
+    refund_amount: string;
+    source: WithdrawalSource;
+}
+export interface WithdrawalPreview {
+    billing_account_id: number;
+    /**
+     * @minLength 3
+     * @maxLength 3
+     */
+    currency: string;
+    /** @pattern ^[0-9]{1,15}([.][0-9]{1,10})?$ */
+    available_amount: string;
+    /** @pattern ^[0-9]{1,15}([.][0-9]{1,10})?$ */
+    amount: string;
+    /** @pattern ^[0-9]{1,15}([.][0-9]{1,10})?$ */
+    fee_amount: string;
+    /** @pattern ^[0-9]{1,15}([.][0-9]{1,10})?$ */
+    refund_amount: string;
+    /** @maxItems 200 */
+    items: WithdrawalPreviewItem[];
+}
+export interface WithdrawalPreviewRequest {
+    billing_account_id: number;
+    /** @pattern ^[0-9]{1,15}([.][0-9]{1,10})?$ */
+    amount?: string;
+}
+export interface WithdrawalCreate {
+    id: string;
+    billing_account_id: number;
+    /** @pattern ^[0-9]{1,15}([.][0-9]{1,10})?$ */
+    amount: string;
+    /** @pattern ^[0-9]{1,15}([.][0-9]{1,10})?$ */
+    expected_refund_amount: string;
+    /**
+     * @minItems 1
+     * @maxItems 200
+     */
+    expected_items: WithdrawalAllocation[];
+}
+export interface WithdrawalList {
+    items: Withdrawal[];
+    pagination: OffsetPagination;
+}
+export interface WithdrawalItemList {
+    items: WithdrawalItem[];
+    pagination: OffsetPagination;
+}
+/**
+ * Whether a delivered purchase may end immediately or only at the end of its paid term; refunds follow the refund policy. When absent, no termination terms were agreed.
+ */
+export type TerminationPolicy = (typeof TerminationPolicy)[keyof typeof TerminationPolicy];
+export declare const TerminationPolicy: {
+    readonly immediate: "immediate";
+    readonly period_end: "period_end";
+};
+/**
+ * `none` refunds nothing. `prorated` refunds the amount paid for the current period minus the value of the time used, never below zero or above what remains unrefunded. Time used runs from the period start to the effective cancellation and is valued at prices frozen on the order item: each full calendar month at `refund_monthly_amount`, the rest at `refund_hourly_amount` or, without it, at the monthly price by the second. When the plan has no licensed period shorter than the one bought, time used is valued pro rata at the price paid. Discounts and setup fees are not refunded. Refunds return to the original payment sources, with tax refunded in proportion.
+ */
+export type RefundPolicy = (typeof RefundPolicy)[keyof typeof RefundPolicy];
+export declare const RefundPolicy: {
+    readonly none: "none";
+    readonly prorated: "prorated";
+};
+export interface OrderCancel {
+    /**
+     * Omit to select all still-pending items. Explicit selections name one or more items of this order; successful items cannot be reversed here.
+     * @minItems 1
+     * @maxItems 100
+     */
+    order_item_ids?: string[];
+}
+export type QuoteRenewalInterval = (typeof QuoteRenewalInterval)[keyof typeof QuoteRenewalInterval];
+export declare const QuoteRenewalInterval: {
+    readonly day: "day";
+    readonly month: "month";
+    readonly year: "year";
+};
+/**
+ * Price renewing a licensed subscription. Give `price_id`, or `interval` with
+ * `interval_count`, to renew for another term at the price currently sold for it. Naming
+ * the current term, or giving neither, renews at the agreed amount. A term sold at several
+ * prices that differ in termination policy is refused with 409
+ * `BILLING_RENEWAL_OPTION_AMBIGUOUS` unless `termination_policy` or `price_id` is given.
+ */
+export interface QuoteRenewal {
+    subscription_id: string;
+    price_id?: string;
+    interval?: QuoteRenewalInterval;
+    /** @minimum 1 */
+    interval_count?: number;
+    /** With `interval` and `interval_count`, chooses among prices of that term that differ in termination policy. */
+    termination_policy?: TerminationPolicy;
+    /**
+     * How many consecutive periods to renew for.
+     * @minimum 1
+     * @maximum 100
+     */
+    periods?: number;
+}
+export type QuoteRenewalResultInterval = (typeof QuoteRenewalResultInterval)[keyof typeof QuoteRenewalResultInterval];
+export declare const QuoteRenewalResultInterval: {
+    readonly day: "day";
+    readonly month: "month";
+    readonly year: "year";
+};
+/**
+ * What renewing would charge. Renewing the same subscription for the same term and periods charges exactly `total` unless prices or the account's discounts change first.
+ */
+export interface QuoteRenewalResult {
+    /** Which renewal of the request this answers. */
+    index: number;
+    subscription_id: string;
+    /** The price the renewal is charged under. */
+    price_id: string;
+    interval: QuoteRenewalResultInterval;
+    interval_count: number;
+    periods: number;
+    /** The price of the periods before the account's discounts, with any discount the subscription carries already reflected; includes tax only where the price does. */
+    amount: Money;
+    /** The reduction from a discount the account holds. */
+    discount_amount: Money;
+    /** Tax on the discounted amount. */
+    tax_amount: Money;
+    /** The part of `tax_amount` already contained in `amount`. */
+    tax_included_amount: Money;
+    /**
+     * What renewing would charge: `amount` less `discount_amount`, plus `tax_amount`, less
+     * `tax_included_amount`.
+     */
+    total: Money;
+}
+/**
+ * One fully calculated purchase, estimated metered usage or recorded order item. Amounts use the
+ * billing-account currency. An item with no immediate charge has zero checkout amounts.
+ */
+export interface QuoteItem {
+    tax_amount: Money;
+    tax_included_amount: Money;
+    /**
+     * The zero-based request line index, or the recorded order item's position for an order quote.
+     * @minimum 0
+     */
+    index: number;
+    /** Present for an existing order quote; identifies the recorded item being priced. */
+    order_item_id?: string;
+    /** The selected price, also when the request identified it indirectly. */
+    price_id: string;
+    plan_name: string;
+    /** Unit price before discounts. Null when no single unit price applies, such as tiered or multiple-rate pricing. */
+    unit_amount: Money | null;
+    /** The quantity priced; with duration_seconds, quantity times the duration. */
+    quantity: string;
+    /** Amount before discounts and including any setup charge. For requested future usage this is an estimate, not a collectible checkout amount. */
+    amount: Money;
+    discount_amount: Money;
+    total: Money;
+    currency: string;
+}
+export type QuotedDiscountType = (typeof QuotedDiscountType)[keyof typeof QuotedDiscountType];
+export declare const QuotedDiscountType: {
+    readonly promotion_code: "promotion_code";
+    readonly account_discount: "account_discount";
+};
+/**
+ * The discount selected for this calculation, not applied and not reserved. Amounts are on the quote and its lines.
+ */
+export interface QuotedDiscount {
+    type: QuotedDiscountType;
+    name: string;
+    /**
+     * Code text for a promotion_code discount; null for an account_discount.
+     * @minLength 1
+     * @maxLength 64
+     * @nullable
+     */
+    promotion_code: string | null;
+}
+/**
+ * Which object this is, together with what a person currently calls it.
+ *
+ * The name is for display. It is chosen by whoever owns the object, it changes, it is not unique
+ * between objects, and it may be empty when nobody has named it yet — so it must not be used to
+ * address, match or deduplicate anything. Addressing is by id.
+ *
+ * This differs from an identity carrying a lookup key: a lookup key is written once by an operator,
+ * is unique, and can be used to fetch the object. A name cannot.
+ */
+export interface NamedIdentity {
+    id: string;
+    /** @maxLength 255 */
+    name: string;
+}
+/**
+ * `one_time` charges once when bought. `recurring` charges again for every period, or for usage as it is settled.
+ */
+export type PriceType = (typeof PriceType)[keyof typeof PriceType];
+export declare const PriceType: {
+    readonly one_time: "one_time";
+    readonly recurring: "recurring";
+};
+/**
+ * `licensed` charges for the quantity bought, each period paid before it starts. `metered` charges for the usage
+ * reported, after it is settled; a metered subscription lasts until it is canceled. A one-time price is licensed.
+ */
+export type UsageType = (typeof UsageType)[keyof typeof UsageType];
+export declare const UsageType: {
+    readonly licensed: "licensed";
+    readonly metered: "metered";
+};
+/**
+ * One subscription of the quoted cancellation.
+ */
+export interface CancellationRefundPreviewItem {
+    subscription_id: string;
+    plan_id: string;
+    plan_name: string;
+    /** The project and its current name. Absent for an account-level purchase or when the project cannot be read. */
+    project?: NamedIdentity | null;
+    type: PriceType;
+    usage_type: UsageType;
+    /** Whether automatic renewal is on now. Creating the cancellation turns it off; withdrawing it turns it back on for a metered subscription but not for a licensed one. */
+    auto_renew: boolean;
+    unused_amount: Money;
+    refundable_amount: Money;
+    refund_amount: Money;
+    credit_amount: Money;
+    tax_amount: Money;
+    forfeited_amount: Money;
+}
+/**
+ * What the cancellation would return, per subscription and in total, as of now. Give `proration_date` and
+ * `refundable_amount` when creating the cancellation.
+ *
+ * - `unused_amount`: before tax, the amount paid for the current periods minus the value of the time used,
+ *   valued as refund policy `prorated` describes, whatever the refund terms say.
+ * - `refundable_amount`: what is returned the way it was paid, tax included; `refund_amount` plus
+ *   `credit_amount`.
+ * - `refund_amount`: the part returned to the balance or the payment method.
+ * - `credit_amount`: the part restored to the credit grants that paid.
+ * - `tax_amount`: the tax included in `refundable_amount`.
+ * - `forfeited_amount`: before tax, the part of `unused_amount` the refund terms do not return.
+ *
+ * Metered and one-time subscriptions show zero; their usage until release is charged as usual.
+ */
+export interface CancellationRefundPreview {
+    mode: TerminationPolicy;
+    /** For `period_end`, when release begins, the end of the paid terms. */
+    scheduled_at?: string;
+    /** For `immediate`, the second the refund is computed as of. Give it when creating the cancellation. */
+    proration_date?: string;
+    currency: string;
+    unused_amount: Money;
+    refundable_amount: Money;
+    refund_amount: Money;
+    credit_amount: Money;
+    tax_amount: Money;
+    forfeited_amount: Money;
+    items: CancellationRefundPreviewItem[];
+}
+/**
+ * An estimated refund to the original payment sources. Before acceptance, cancellation returns the collected amount. For delivered service, only value paid by this order is included; renewals are evaluated with their own orders under the agreed termination terms. Nothing is refunded by the quote; the amount is fixed when cancellation or termination is confirmed.
+ */
+export interface OrderRefundQuote {
+    order_id: string;
+    refundable_amount: Money;
+    refund_amount: Money;
+    credit_amount: Money;
+    currency: string;
+}
+/**
+ * A complete calculation in the billing account's currency; nothing is saved or reserved. The request fails if any item cannot be priced. Usage estimates are included in totals but are not collected at checkout; only an existing-order quote gives that order's checkout amount.
+ */
+export interface Quote5f60d00 {
+    /** Account funds for an existing-order checkout quote. Absent for usage estimates, refunds and cancellations. */
+    funds?: Funds;
+    subtotal: Money;
+    discount_amount: Money;
+    tax_amount: Money;
+    /** The discount a purchase or order would get, not yet applied. Null when there is none, and for renewals and cancellations. A confirmed order reports its recorded discount. */
+    discount: QuotedDiscount | null;
+    items: QuoteItem[];
+    renewals: QuoteRenewalResult[];
+    /** What the cancellation requested would return. Present only when one was requested. */
+    cancellation?: CancellationRefundPreview;
+    total: Money;
+    currency: string;
+    /** Present when an order refund was requested. */
+    refund?: OrderRefundQuote;
+}
+export type QuoteA200529 = Quote5f60d00;
+/**
+ * A cancellation to quote: what ending these subscriptions together would return, for one mode; quote `immediate` and `period_end` separately to compare. Refused with 409 `BILLING_SUBSCRIPTION_OPERATION_PENDING` when a subscription is already being canceled (`meta.cancellation_id`), is being reclaimed (`meta.reason` `reclaim_requested`) or has a paid change waiting to switch (`meta.order_id`).
+ */
+export interface QuoteCancellation {
+    /**
+     * The subscriptions to end together, all of one service, including every subscription released with a resource.
+     * @minItems 1
+     * @maxItems 50
+     */
+    subscription_ids: string[];
+    mode: TerminationPolicy;
+}
+export interface CancellationCreate {
+    /**
+     * As in the quote.
+     * @minItems 1
+     * @maxItems 50
+     */
+    subscription_ids: string[];
+    mode: TerminationPolicy;
+    /** For `immediate`, the quote's `proration_date`: a whole second, not in the future and at most ten minutes old; the refund is computed as of it. Now when omitted. */
+    proration_date?: string;
+    /** The quote's `refundable_amount`; the cancellation is refused when the refund differs. */
+    expected_refundable_amount: Money & string;
+    /**
+     * A note from the account holder, kept with the cancellation.
+     * @maxLength 1024
+     */
+    reason?: string;
+}
+export type CancellationStatus = (typeof CancellationStatus)[keyof typeof CancellationStatus];
+export declare const CancellationStatus: {
+    readonly requested: "requested";
+    readonly scheduled: "scheduled";
+    readonly releasing: "releasing";
+    readonly completed: "completed";
+    readonly canceled: "canceled";
+    readonly failed: "failed";
+};
+/**
+ * Who requested it; `project_deletion` means the project was deleted.
+ */
+export type CancellationOrigin = (typeof CancellationOrigin)[keyof typeof CancellationOrigin];
+export declare const CancellationOrigin: {
+    readonly customer: "customer";
+    readonly operator: "operator";
+    readonly project_deletion: "project_deletion";
+};
+export type CancellationItemStatus = (typeof CancellationItemStatus)[keyof typeof CancellationItemStatus];
+export declare const CancellationItemStatus: {
+    readonly requested: "requested";
+    readonly scheduled: "scheduled";
+    readonly releasing: "releasing";
+    readonly completed: "completed";
+    readonly canceled: "canceled";
+    readonly failed: "failed";
+};
+/**
+ * One subscription of the cancellation.
+ */
+export interface CancellationItem {
+    /** The subscription's cancellation item, the same as `Subscription.cancellation.id`. */
+    id: string;
+    subscription_id: string;
+    plan_id: string;
+    plan_name: string;
+    type: PriceType;
+    /**
+     * Creating the cancellation turned automatic renewal off; withdrawing it turns renewal back on
+     * for a `metered` subscription and leaves it off for a `licensed` one.
+     */
+    usage_type: UsageType;
+    status: CancellationItemStatus;
+    /** The release stopped or its result is unknown; present while the release needs resolution. */
+    failure_code?: string;
+    release_started_at?: string;
+    /** When the service ended, as confirmed by the service that provides it. */
+    effective_at?: string;
+    /** Present with `completed`. The part of the refund returned to the account balance. */
+    balance_amount?: Money;
+    /** Present with `completed`. The part restored to the credit grants that paid. */
+    credit_amount?: Money;
+    /** Present with `completed`. The part returned to the payment method it was paid with. */
+    gateway_amount?: Money;
+}
+/**
+ * One cancellation of a set of subscriptions of one service, released together at one time.
+ *
+ * - `requested`: `immediate`, release has not begun.
+ * - `scheduled`: `period_end`, waiting for `scheduled_at`.
+ * - `releasing`: release has begun; it can no longer be withdrawn.
+ * - `completed`: every subscription has ended and its refund has been made.
+ * - `canceled`: withdrawn before release began; the subscriptions continue.
+ * - `failed`: the service could not carry it out, for the reason in `failure_code`; the
+ *   subscriptions continue and can be canceled again.
+ */
+export interface Cancellation {
+    id: string;
+    status: CancellationStatus;
+    mode: TerminationPolicy;
+    scheduled_at?: string;
+    /** For `immediate`, the second the refund is computed as of. */
+    proration_date?: string;
+    /** Who requested it; `project_deletion` means the project was deleted. */
+    origin: CancellationOrigin;
+    /** The billing account paying for these subscriptions when the cancellation was created: the purchasing account of an account-level purchase, or the project's linked account. */
+    billing_account_id: number;
+    currency: string;
+    /** The refund confirmed when the cancellation was created. Absent when the platform created it. */
+    expected_refundable_amount?: Money;
+    /** Present with `failed`: the owning service's code, such as for a disk that can only be released with its server. */
+    failure_code?: string;
+    requested_at: string;
+    completed_at?: string;
+    canceled_at?: string;
+    items: CancellationItem[];
+}
+export interface CancellationList {
+    items: Cancellation[];
+    pagination: OffsetPagination;
+}
+export type SubscriptionCancellationStatus = (typeof SubscriptionCancellationStatus)[keyof typeof SubscriptionCancellationStatus];
+export declare const SubscriptionCancellationStatus: {
+    readonly requested: "requested";
+    readonly scheduled: "scheduled";
+    readonly releasing: "releasing";
+    readonly failed: "failed";
+    readonly completed: "completed";
+    readonly canceled: "canceled";
+};
+export type SubscriptionCancellationMode = (typeof SubscriptionCancellationMode)[keyof typeof SubscriptionCancellationMode];
+export declare const SubscriptionCancellationMode: {
+    readonly immediate: "immediate";
+    readonly period_end: "period_end";
+};
+/**
+ * The latest cancellation including the subscription, with this subscription's item: `id` is the item and `cancellation_id` the cancellation. scheduled_at is the intended time and effective_at the confirmed end of service.
+ */
+export interface SubscriptionCancellation {
+    reason?: string;
+    /** The cancellation this item belongs to, with the other subscriptions released together. */
+    cancellation_id?: string;
+    id: string;
+    subscription_id: string;
+    status: SubscriptionCancellationStatus;
+    mode: SubscriptionCancellationMode;
+    requested_at: string;
+    scheduled_at?: string;
+    effective_at?: string;
+    completed_at?: string;
+    release_started_at?: string;
+    canceled_at?: string;
+    forfeit_remaining_value: boolean;
+    failure_code?: string;
+    failure_reason?: string;
+}
+export type ErrorA200529 = Error;
+/**
+ * The platform service's fixed identifier, such as compute, canopy or assistant.
+ * @minLength 1
+ * @maxLength 64
+ * @pattern ^[a-z][a-z0-9]*(-[a-z0-9]+)*$
+ */
+export type ProductID = string;
+export interface Product {
+    id: ProductID;
+    name: string;
+    description?: string;
+}
+export type BillingAccountStatus = (typeof BillingAccountStatus)[keyof typeof BillingAccountStatus];
+export declare const BillingAccountStatus: {
+    readonly active: "active";
+    readonly suspended: "suspended";
+    readonly closed: "closed";
+};
+export interface BillingAccount {
+    /**
+     * The active contact used for invoices, of this account; null clears it.
+     * @nullable
+     */
+    invoice_contact_id?: string | null;
+    id: number;
+    /** Your name for the account. */
+    name?: string;
+    /** Fixed when the account was opened. */
+    currency: string;
+    status: BillingAccountStatus;
+    /** How far past the suspension threshold the account may go before its resources are suspended; `0` means none. */
+    grace_amount?: string;
+    /** How long the account has to top up after crossing the suspension threshold, in seconds; `0` means none. Grace ends when this or grace_amount runs out. */
+    grace_period_seconds?: number;
+    /**
+     * When the account was closed. Null if it is not closed or the time is unknown.
+     * @nullable
+     */
+    readonly closed_at?: string | null;
+    created_at: string;
+}
+/**
+ * A currency a billing account can be opened in.
+ */
+export interface Currency {
+    /**
+     * ISO 4217 alpha-3, uppercase.
+     * @minLength 3
+     * @maxLength 3
+     */
+    code: string;
+    /**
+     * Decimal places of the ISO 4217 minor unit.
+     * @minimum 0
+     * @maximum 4
+     */
+    exponent: number;
+    /**
+     * @minLength 1
+     * @maxLength 64
+     */
+    name: string;
+    minimum_top_up: Money;
+}
+export interface CurrencyList {
+    items: Currency[];
+    pagination: OffsetPagination;
+}
+export interface BillingAccountCreate {
+    /**
+     * @minLength 3
+     * @maxLength 3
+     */
+    currency: string;
+    /** @maxLength 255 */
+    name?: string;
+}
+export interface BillingAccountUpdate {
+    /**
+     * The active contact used for invoices, of this account; null clears it.
+     * @nullable
+     */
+    invoice_contact_id?: string | null;
+    /** @maxLength 255 */
+    name?: string;
+}
+export interface BillingAccountList {
+    items: BillingAccount[];
+    pagination: OffsetPagination;
+}
+/**
+ * A plan referenced by an applicability; active is false once it is archived, and the reference still applies.
+ */
+export interface ApplicablePlan {
+    id: string;
+    name: string;
+    active: boolean;
+}
+/**
+ * A catalog object, inlined for display.
+ */
+export interface ObjectIdentity {
+    lookup_key?: string;
+    id: string;
+    name: string;
+}
+/**
+ * `per_unit` multiplies a unit amount; `tiered` walks a ladder.
+ */
+export type BillingScheme = (typeof BillingScheme)[keyof typeof BillingScheme];
+export declare const BillingScheme: {
+    readonly per_unit: "per_unit";
+    readonly tiered: "tiered";
+};
+export type PriceOptionInterval = (typeof PriceOptionInterval)[keyof typeof PriceOptionInterval];
+export declare const PriceOptionInterval: {
+    readonly none: "none";
+    readonly day: "day";
+    readonly month: "month";
+    readonly year: "year";
+};
+/**
+ * A price's display terms, including archived prices referenced by an applicability.
+ */
+export interface PriceOption {
+    product: Product;
+    plan: ObjectIdentity;
+    /** Absent when the price delegates to a rate card. */
+    billing_scheme?: BillingScheme;
+    unit_quantity: string;
+    id: string;
+    currency: string;
+    type: PriceType;
+    usage_type: UsageType;
+    interval: PriceOptionInterval;
+    /** How many periods one purchase covers. */
+    interval_count?: number;
+    unit_amount?: Money;
+    /** False once the price is archived. It still applies to purchases already made at this price. */
+    active: boolean;
+}
+/**
+ * The purchase operation covered. `new`: every new purchase, including zero-charge ones; it does not mean the account's first purchase, which `first_purchase_only` restricts. `renew`: renewals. `modify`: configuration or billing-term changes, whether they charge, refund or neither.
+ */
+export type PurchaseOperation = (typeof PurchaseOperation)[keyof typeof PurchaseOperation];
+export declare const PurchaseOperation: {
+    readonly new: "new";
+    readonly renew: "renew";
+    readonly modify: "modify";
+};
+/**
+ * Covers anything not excluded that matches an inclusion, or anything not excluded when no inclusion is given, subject to the price type, usage type, operation and term conditions. Archived plans and prices stay listed with active false.
+ */
+export interface Applicability {
+    products?: Product[];
+    plans?: ApplicablePlan[];
+    prices?: PriceOption[];
+    /** The price types covered; empty covers both. */
+    price_types?: PriceType[];
+    /** The usage types covered; empty covers both. */
+    usage_types?: UsageType[];
+    operations?: PurchaseOperation[];
+    /** The shortest term a purchase may have, in months. Purchases without a term, such as metered usage, do not qualify while this is set. */
+    min_term_months?: number;
+    /** The longest term a purchase may have, in months. */
+    max_term_months?: number;
+    excluded_products?: Product[];
+    excluded_plans?: ApplicablePlan[];
+    excluded_prices?: PriceOption[];
+}
+export interface CreditGroup {
+    /** What the credit in this group may pay for; no restrictions means anything on the account. */
+    applies_to: Applicability;
+    /** Restricted to your first purchase of anything it applies to. */
+    first_purchase_only?: boolean;
+    amount: Money;
+}
+/**
+ * Balance, credits and unpaid charges, each reported separately.
+ */
+export interface AccountBalance {
+    /** Balance minus pending balance returns and the part of unbilled_amount and due that estimated_credit_applied does not cover. Negative only when the balance and applicable credit fall short of what the account owes. */
+    available_credit: Money;
+    /** Credit expected to pay unbilled_amount and due, matching each charge to the grants whose scope, validity and conditions it meets, in the order credit is applied at payment. Nothing is deducted until an invoice is paid, so credits still includes this amount. */
+    estimated_credit_applied: Money;
+    /** Current estimate of priced usage that has not been invoiced. Final pricing and tax are fixed at issuance. */
+    unbilled_amount: Money;
+    billing_account_id: number;
+    currency: string;
+    /** Topped-up funds in the account's currency, excluding credits. May be negative after a payment dispute. Amounts owed are reported in due; this is not a withdrawable amount. */
+    balance: Money;
+    /** Remaining credit, including restricted grants; not withdrawable and not part of balance. credit_groups shows currently valid credit by permitted use; positive credits do not mean due is zero. */
+    credits: Money;
+    /** Currently valid credit restricted to certain products, operations or conditions; part of credits, not of balance. */
+    restricted_credits: Money;
+    /** Currently valid unspent credit grouped by permitted use. Each group covers only the charges its restrictions and validity allow, and the groups may differ from the recorded credits total. */
+    credit_groups: CreditGroup[];
+    /** Amount still payable on issued invoices. The invoice of an order not yet accepted is excluded, here and from available_credit. Usage not yet invoiced is reported separately. */
+    due: Money;
+    pending_returns_amount: Money;
+}
+/**
+ * A project's assignment to a billing account from effective_from until effective_to; an open assignment has no end.
+ */
+export interface ProjectAssignment {
+    project_id: string;
+    /** The project and its current name. Absent when the project cannot be read; `project_id` still identifies it. */
+    project?: NamedIdentity | null;
+    billing_account_id: number;
+    account_name?: string;
+    currency: string;
+    effective_from: string;
+    /** @nullable */
+    effective_to?: string | null;
+}
+export interface ProjectAssignmentList {
+    items: ProjectAssignment[];
+    pagination: OffsetPagination;
+}
+export interface SetProjectAssignmentRequest {
+    billing_account_id: number;
+}
+/**
+ * `pending` until the payment gateway reaches a result; the balance increases on `succeeded`. `failed`: the gateway declined the payment, which is withdrawn at the gateway; create a new top-up to pay another way. `canceled`: withdrawn without collecting money, for the reason in `cancellation_reason`. Unknown gateway outcomes stay `pending`; a browser redirect is not proof of payment. `failed` and `canceled` are final; a payment the gateway collects afterwards is credited as a separate `succeeded` top-up.
+ */
+export type TopUpStatus = (typeof TopUpStatus)[keyof typeof TopUpStatus];
+export declare const TopUpStatus: {
+    readonly pending: "pending";
+    readonly succeeded: "succeeded";
+    readonly failed: "failed";
+    readonly canceled: "canceled";
+};
+export interface AccountIdentity {
+    id: number;
+    name: string;
+    currency: string;
+}
+/**
+ * Why a gateway payment was withdrawn: `abandoned` when the customer did not complete it in time, `requested_by_customer` when the customer canceled it.
+ */
+export type PaymentCancellationReason = (typeof PaymentCancellationReason)[keyof typeof PaymentCancellationReason];
+export declare const PaymentCancellationReason: {
+    readonly abandoned: "abandoned";
+    readonly requested_by_customer: "requested_by_customer";
+};
+export type PaymentActionType = (typeof PaymentActionType)[keyof typeof PaymentActionType];
+export declare const PaymentActionType: {
+    readonly redirect: "redirect";
+    readonly qr_code: "qr_code";
+    readonly sdk: "sdk";
+};
+/**
+ * The customer's next step; the payment outcome is reported separately.
+ */
+export interface PaymentAction {
+    type: PaymentActionType;
+    /** The browser adapter for the action, for example stripe. */
+    provider?: string;
+    url?: string;
+    /** QR content to render, not an image URL. */
+    qr_code?: string;
+    /** Short-lived client credential for confirming this payment in the browser. */
+    client_secret?: string;
+    public_key?: string;
+}
+/**
+ * A top-up attempt and its outcome. A successful top-up adds to the balance; it is not a credit grant and has no invoice.
+ */
+export interface TopUp {
+    id: string;
+    billing_account_id: number;
+    account: AccountIdentity;
+    /** What is credited to the account, in its currency. */
+    amount: Money;
+    currency: string;
+    /** The part of this top-up still in the balance. Pending refunds may hold part of it, so not all of it is necessarily withdrawable. */
+    remaining_amount?: Money;
+    /** `pending` until the payment gateway reaches a result; the balance increases on `succeeded`. `failed`: the gateway declined the payment, which is withdrawn at the gateway; create a new top-up to pay another way. `canceled`: withdrawn without collecting money, for the reason in `cancellation_reason`. Unknown gateway outcomes stay `pending`; a browser redirect is not proof of payment. `failed` and `canceled` are final; a payment the gateway collects afterwards is credited as a separate `succeeded` top-up. */
+    status: TopUpStatus;
+    cancellation_reason?: PaymentCancellationReason;
+    /** Which payment gateway collected it. */
+    payment_gateway?: string;
+    /** The selected payment method, such as card, wechat_pay or alipay. */
+    method_type?: string;
+    /** The currency the customer was charged in when the checkout collected a local currency; absent when it is the account's. */
+    presentment_currency?: string;
+    /** The amount charged in `presentment_currency`, as shown on the customer's statement. */
+    presentment_amount?: Money;
+    /** Why the gateway declined it; present with `failed`. The gateway's code unchanged: the issuer's decline code when there is one (Stripe decline_code, such as insufficient_funds), otherwise the gateway's error code (Stripe code, such as card_declined). Treat an unknown value as a generic decline. */
+    failure_reason?: string;
+    action?: PaymentAction;
+    created_at: string;
+    /**
+     * When the funds arrived, possibly days after `created_at`. Absent until the payment completes.
+     * @nullable
+     */
+    settled_at?: string | null;
+}
+export interface TopUpCreate {
+    /**
+     * The gateway selected from the available payment options.
+     * @minLength 1
+     * @maxLength 32
+     */
+    payment_gateway: string;
+    /**
+     * The selected method, such as card, wechat_pay or alipay.
+     * @minLength 1
+     * @maxLength 64
+     */
+    method_type: string;
+    /** The top-up ID, chosen by the caller. Read it after an uncertain response. */
+    id: string;
+    billing_account_id: number;
+    /** In the account's currency, no finer than its smallest unit (two decimals for most currencies, none for JPY). An amount below the currency's minimum top-up is refused, and the minimum is returned with the error. */
+    amount: Money & string;
+    /** Charge a saved payment method instead of opening a checkout page. */
+    payment_method_id?: string;
+    /** Where to send the customer after checkout. */
+    return_url?: string;
+}
+export interface TopUpList {
+    items: TopUp[];
+    pagination: OffsetPagination;
+}
+export interface PaymentOptionMethod {
+    /** The value to send as `method_type`, such as card, wechat_pay or alipay. */
+    method_type: string;
+    /** Whether this method type can be saved with create-payment-method-setup and charged later without the customer. */
+    reusable: boolean;
+}
+/**
+ * A gateway accepting the account's currency, with its payment methods.
+ */
+export interface PaymentOption {
+    /** The value to send as `payment_gateway`. */
+    payment_gateway: string;
+    methods: PaymentOptionMethod[];
+}
+export interface PaymentOptionList {
+    items: PaymentOption[];
+    pagination: OffsetPagination;
+}
+export type PaymentMethodStatus = (typeof PaymentMethodStatus)[keyof typeof PaymentMethodStatus];
+export declare const PaymentMethodStatus: {
+    readonly active: "active";
+    readonly expired: "expired";
+    readonly removed: "removed";
+};
+export interface PaymentMethod {
+    id: string;
+    billing_account_id: number;
+    payment_gateway: string;
+    brand?: string;
+    last4?: string;
+    /** @nullable */
+    exp_month?: number | null;
+    /** @nullable */
+    exp_year?: number | null;
+    is_default: boolean;
+    status: PaymentMethodStatus;
+}
+export interface PaymentMethodList {
+    items: PaymentMethod[];
+    pagination: OffsetPagination;
+}
+export interface PaymentMethodSetup {
+    /**
+     * The selected gateway supporting saved payment methods.
+     * @minLength 1
+     * @maxLength 32
+     */
+    payment_gateway: string;
+    billing_account_id: number;
+}
+/**
+ * What the payment gateway's browser library needs to collect a card in the page; the card goes from the browser straight to the gateway.
+ */
+export interface PaymentMethodSetupResult {
+    /** The gateway's identifier for this attempt. */
+    setup_id: string;
+    payment_gateway: string;
+    action: PaymentAction;
+}
+/**
+ * Applies eligible credit grants and the available balance as requested, then collects only the remainder
+ * through the selected gateway. Grants restricted to other purchases are not counted as available funds.
+ * An unresolved channel payment is reused; retries do not apply the grant or balance portions twice.
+ * Without a gateway selection, insufficient account funds fail without starting an online payment.
+ *
+ * `payment_gateway` and `method_type` are given together, and `payment_method_id` only with both;
+ * otherwise the request is refused with `BILLING_PURCHASE_INVALID`.
+ */
+export interface PayInvoiceRequest {
+    /**
+     * Required to collect an online remainder. An existing attempt keeps its gateway.
+     * @minLength 1
+     * @maxLength 32
+     */
+    payment_gateway?: string;
+    /**
+     * Required with payment_gateway; for example card, wechat_pay or alipay.
+     * @minLength 1
+     * @maxLength 64
+     */
+    method_type?: string;
+    /** A saved card of this billing account at the selected gateway. Omit to pay interactively. */
+    payment_method_id?: string;
+    /** Whether to apply the balance; credit grants are controlled by use_credits. */
+    use_balance?: boolean;
+    /** Apply eligible, unexpired credit grants before the balance. Grants are never converted into balance. */
+    use_credits?: boolean;
+    return_url?: string;
+    /**
+     * The code to apply while the order's terms are not fixed. Omit to apply the best applicable account discount, or to keep the discount already recorded.
+     * @minLength 1
+     * @maxLength 64
+     */
+    promotion_code?: string;
+    /** The invoice total to expect, after discounts and tax and before credit grants or balance, as the payment preview or an order quote gave it. A different total fails with `BILLING_AMOUNT_CHANGED` and nothing is charged. Omit to skip the check; zero is checked. */
+    expected_amount?: Money & string;
+}
+/**
+ * Name at least one invoice or order. All must belong to one account in its currency.
+ */
+export interface PayTogetherRequest {
+    /** @maxItems 100 */
+    invoice_ids?: string[];
+    /** @maxItems 100 */
+    order_ids?: string[];
+    /** The amount due across all invoices, before credit grants or balance, as preview-pay-together gave it. A different amount fails with `BILLING_AMOUNT_CHANGED` and nothing is charged. Omit to skip the check. */
+    expected_amount?: Money & string;
+}
+/**
+ * `succeeded`: paid. `processing`: confirmation is pending; poll the invoice or order instead of paying again. `requires_action`: the customer must complete the returned action. `failed`: the attempt did not succeed, for the reason in failure_reason; a declined gateway payment is withdrawn, and paying again starts a new payment.
+ */
+export type PaymentStatus = (typeof PaymentStatus)[keyof typeof PaymentStatus];
+export declare const PaymentStatus: {
+    readonly succeeded: "succeeded";
+    readonly processing: "processing";
+    readonly requires_action: "requires_action";
+    readonly failed: "failed";
+};
+/**
+ * A credit grant and what it would pay.
+ */
+export interface AppliedCredit {
+    credit_grant_id: string;
+    name: string;
+    amount: Money;
+}
+export interface PaymentPreviewInvoice {
+    invoice_id: string;
+    /** @nullable */
+    order_id?: string | null;
+    amount_due: Money;
+    credit_applied: Money;
+    balance_applied: Money;
+}
+/**
+ * What paying would take, calculated as paying does. Nothing is charged or reserved.
+ */
+export interface PaymentPreview {
+    funds?: Funds;
+    currency: string;
+    /** What is outstanding before paying. */
+    amount_due: Money;
+    /** What credit grants would pay. Grants restricted to other purchases pay nothing here. */
+    credit_applied: Money;
+    /** The credit grants that would pay, in the order used. */
+    credit_grants: AppliedCredit[];
+    /** What the balance would pay. */
+    balance_applied: Money;
+    /** What would remain to pay online. Paying without a gateway is refused with `BILLING_INSUFFICIENT_FUNDS` while this is above zero. */
+    gateway_amount: Money;
+    /** The available balance after paying. */
+    balance_after: Money;
+    /** Paying together only: each invoice, in payment order. */
+    invoices?: PaymentPreviewInvoice[];
+}
+/**
+ * Present on refunds: where this part goes. `balance`: the account balance. `credit`: the credit grant that paid, keeping its original expiry. `gateway`: the payment method it was paid with.
+ */
+export type TransactionRefundDestination = (typeof TransactionRefundDestination)[keyof typeof TransactionRefundDestination];
+export declare const TransactionRefundDestination: {
+    readonly balance: "balance";
+    readonly credit: "credit";
+    readonly gateway: "gateway";
+};
+/**
+ * `failed`: the operation did not succeed; for a gateway payment, the gateway declined it. `canceled`: a gateway payment was withdrawn without collecting money. Either way, the invoice it was for stays open.
+ */
+export type TransactionStatus = (typeof TransactionStatus)[keyof typeof TransactionStatus];
+export declare const TransactionStatus: {
+    readonly pending: "pending";
+    readonly succeeded: "succeeded";
+    readonly failed: "failed";
+    readonly canceled: "canceled";
+};
+/**
+ * topup adds to the balance; payment settles an invoice; refund returns original funds; adjustment changes the balance with an audit reason.
+ */
+export type TransactionType = (typeof TransactionType)[keyof typeof TransactionType];
+export declare const TransactionType: {
+    readonly topup: "topup";
+    readonly payment: "payment";
+    readonly refund: "refund";
+    readonly adjustment: "adjustment";
+    readonly fee: "fee";
+};
+/**
+ * A funds movement with one source. Refunds name the original transaction. Unknown gateway results stay pending.
+ */
+export interface Transaction {
+    invoice_id?: string;
+    transaction_id?: string;
+    /** The credit grant that paid, or for a refund, the credit grant restored. */
+    credit_grant_id?: string;
+    credit_grant?: ObjectIdentity;
+    refund_id?: string;
+    /** Present on refunds: where this part goes. `balance`: the account balance. `credit`: the credit grant that paid, keeping its original expiry. `gateway`: the payment method it was paid with. */
+    refund_destination?: TransactionRefundDestination;
+    /** `failed`: the operation did not succeed; for a gateway payment, the gateway declined it. `canceled`: a gateway payment was withdrawn without collecting money. Either way, the invoice it was for stays open. */
+    status?: TransactionStatus;
+    cancellation_reason?: PaymentCancellationReason;
+    payment_gateway?: string;
+    method_type?: string;
+    /** Why it failed; present with `failed`. For a declined gateway payment, the gateway's code unchanged: the issuer's decline code when there is one (Stripe decline_code, such as insufficient_funds), otherwise the gateway's error code (Stripe code, such as card_declined). Treat an unknown value as a generic decline. */
+    failure_reason?: string;
+    settled_at?: string;
+    id: string;
+    billing_account_id?: number;
+    type: TransactionType;
+    /** Signed by type: positive for `topup` and `payment`, negative for `refund`. An `adjustment` is positive when it adds to the balance and negative when it takes from it. For other types the sign does not show the effect on the balance: a payment from balance lowers it, a payment by gateway or credit does not. */
+    amount: Money;
+    /** How much of this transaction is still in the balance. Only top-ups, positive adjustments and gateway payments returned to the balance can be non-zero. */
+    remaining_amount: Money;
+    currency: string;
+    reason?: string;
+    created_at: string;
+}
+export interface PaymentResult {
+    transactions: Transaction[];
+    /** The gateway transaction, when one is involved. */
+    transaction_id?: string;
+    status: PaymentStatus;
+    amount_paid: Money;
+    /** What is still outstanding: zero once the payment succeeds, unchanged while `processing`. */
+    amount_due: Money;
+    currency: string;
+    credit_applied?: Money;
+    gateway_amount?: Money;
+    payment_gateway?: string;
+    method_type?: string;
+    /** The amount already paid from balance toward this invoice; retrying the online remainder does not debit it again. */
+    balance_applied?: Money;
+    action?: PaymentAction;
+    /** Whether paying again can succeed. False for a refusal that will repeat, such as a closed account or an amount over a limit. */
+    retriable?: boolean;
+    /** @nullable */
+    invoice_id?: string | null;
+    /** @nullable */
+    order_id?: string | null;
+    /** Why the payment failed; present with `failed`. For a declined gateway payment, the gateway's code unchanged: the issuer's decline code when there is one (Stripe decline_code, such as insufficient_funds), otherwise the gateway's error code (Stripe code, such as card_declined). Treat an unknown value as a generic decline. */
+    failure_reason?: string;
+}
+/**
+ * How tax applied to the customer when the invoice was issued; `reverse` means no tax was charged under the reverse-charge mechanism.
+ */
+export type InvoiceCustomerTaxExempt = (typeof InvoiceCustomerTaxExempt)[keyof typeof InvoiceCustomerTaxExempt];
+export declare const InvoiceCustomerTaxExempt: {
+    readonly none: "none";
+    readonly exempt: "exempt";
+    readonly reverse: "reverse";
+};
+/**
+ * Tax name, rate and amounts frozen on the invoice.
+ */
+export interface TaxItem {
+    id: string;
+    invoice_id: string;
+    name: string;
+    percentage: string;
+    country: string;
+    state?: string;
+    taxable_amount: string;
+    tax_amount: string;
+    currency: string;
+}
+export interface Invoice {
+    /** Collection has stopped; accepted return obligations are completed. */
+    void_requested_at?: string;
+    due_at?: string;
+    amount_refunded?: string;
+    tax_items: TaxItem[];
+    id: string;
+    billing_account_id: number;
+    /** Numbered per account and per month. */
+    number: string;
+    currency: string;
+    status: InvoiceStatus;
+    /**
+     * Sum of the line amounts before discounts. Where prices include tax, the tax contained in
+     * each line's discounted amount is taken out here, so that total = subtotal -
+     * discount_amount + tax_amount always holds.
+     */
+    subtotal?: Money;
+    /** Sum of the line discounts, taken off before tax. */
+    discount_amount?: Money;
+    tax_amount?: Money;
+    /** Successful credit-grant payments, included in amount_paid; they do not reduce the receivable or tax base. */
+    credit_applied?: Money;
+    /** Subtotal less discount plus tax. Balance and credit grants pay it; they do not reduce it. */
+    total: Money;
+    amount_paid?: Money;
+    /** Issued credit notes that reduced unpaid receivables; the original invoice total is unchanged. */
+    pre_payment_credit_notes_amount: Money;
+    /** Issued credit notes against payments already received; their refunds may not have completed. */
+    post_payment_credit_notes_amount: Money;
+    /** What is still collectible after unpaid credit notes and successful payments; never below zero. Zero for a draft, whose total is the base price, and for a paid or void invoice. */
+    amount_due: Money;
+    /** @nullable */
+    period_start?: string | null;
+    /**
+     * Exclusive.
+     * @nullable
+     */
+    period_end?: string | null;
+    /** The billing details recorded when the invoice was issued. */
+    customer_name?: string;
+    customer_email?: string;
+    customer_tax_id?: string;
+    /** How tax applied to the customer when the invoice was issued; `reverse` means no tax was charged under the reverse-charge mechanism. */
+    customer_tax_exempt?: InvoiceCustomerTaxExempt;
+    customer_address_line1?: string;
+    customer_address_line2?: string;
+    customer_address_city?: string;
+    customer_address_state?: string;
+    customer_address_postal_code?: string;
+    customer_address_country?: string;
+    /** @nullable */
+    paid_at?: string | null;
+}
+export interface InvoiceList {
+    items: Invoice[];
+    pagination: OffsetPagination;
+}
+export type InvoiceItemType = (typeof InvoiceItemType)[keyof typeof InvoiceItemType];
+export declare const InvoiceItemType: {
+    readonly usage: "usage";
+    readonly subscription: "subscription";
+    readonly one_time: "one_time";
+    readonly setup: "setup";
+    readonly adjustment: "adjustment";
+};
+/**
+ * For a usage line, the values of its meter's presentation dimensions, such as the model and token kind. Empty for other lines.
+ */
+export type InvoiceItemDimensions = {
+    [key: string]: string;
+};
+/**
+ * The value of one paid period moved to the new configuration of a subscription.
+ */
+export interface InvoiceItemProration {
+    /** The earlier invoice line that paid for the period. */
+    credited_invoice_item_id: string;
+    /** The earlier invoice line's wording as recorded. */
+    description: string;
+    period_start: string;
+    /** Exclusive. */
+    period_end: string;
+    /** Before tax and discounts, the new configuration for the period. */
+    remaining_amount: Money;
+    /** Before tax, the unused value of the earlier line for the period, credited against `remaining_amount`. */
+    credited_amount: Money;
+}
+export interface InvoiceItem {
+    taxable?: boolean;
+    /** Discount applied to this line before tax. */
+    discount_amount?: string;
+    /**
+     * The account discount applied to this line.
+     * @nullable
+     */
+    discount_id?: string | null;
+    /**
+     * The coupon applied to this line.
+     * @nullable
+     */
+    coupon_id?: string | null;
+    /** Tax on the discounted line, including tax already included in the price. */
+    tax_amount?: string;
+    /** The part of tax_amount already included in amount. */
+    tax_included_amount?: string;
+    id: string;
+    type?: InvoiceItemType;
+    /** @nullable */
+    project_id?: string | null;
+    /** The project the charge was for and its current name. Absent when the line has no project or the project cannot be read; `project_id` still identifies it. */
+    project?: NamedIdentity | null;
+    resource_id?: string;
+    /** The line's wording as recorded when the invoice was issued. */
+    description: string;
+    unit?: string;
+    quantity?: string;
+    /** The part covered by an included allowance, and therefore not charged. */
+    deducted_quantity?: string;
+    unit_amount?: Money;
+    amount: Money;
+    currency: string;
+    /** @nullable */
+    period_start?: string | null;
+    /** @nullable */
+    period_end?: string | null;
+    /** For a usage line, the values of its meter's presentation dimensions, such as the model and token kind. Empty for other lines. */
+    dimensions?: InvoiceItemDimensions;
+    /**
+     * Present on a line that changes a subscription immediately, one entry for each paid period it
+     * covers. `amount` is the sum of `remaining_amount` minus `credited_amount` over the entries.
+     */
+    prorations?: InvoiceItemProration[];
+}
+export interface InvoiceItemList {
+    items: InvoiceItem[];
+    pagination: OffsetPagination;
+}
+export interface TransactionList {
+    items: Transaction[];
+    pagination: OffsetPagination;
+}
+export type CreditGrantStatus = (typeof CreditGrantStatus)[keyof typeof CreditGrantStatus];
+export declare const CreditGrantStatus: {
+    readonly active: "active";
+    readonly depleted: "depleted";
+    readonly expired: "expired";
+    readonly voided: "voided";
+};
+export interface CreditGrant {
+    min_amount?: string;
+    id: string;
+    billing_account_id?: number;
+    name: string;
+    amount: Money;
+    remaining_amount: Money;
+    currency: string;
+    /** What this credit may pay for. No restrictions means anything on the account. */
+    applies_to: Applicability;
+    /** Restricted to your first purchase of anything it applies to. */
+    first_purchase_only?: boolean;
+    status: CreditGrantStatus;
+    valid_from: string;
+    /** @nullable */
+    valid_until?: string | null;
+}
+export interface CreditGrantList {
+    items: CreditGrant[];
+    pagination: OffsetPagination;
+}
+export type CreditNoteStatus = (typeof CreditNoteStatus)[keyof typeof CreditNoteStatus];
+export declare const CreditNoteStatus: {
+    readonly issued: "issued";
+    readonly void: "void";
+};
+/**
+ * Why the note was issued. Notes for canceled, expired or failed orders carry the order's reason; `usage_true_up` returns a tier price reduction settled after the original invoice; `operator` was issued on request.
+ */
+export type CreditNoteReason = (typeof CreditNoteReason)[keyof typeof CreditNoteReason];
+export declare const CreditNoteReason: {
+    readonly provisioning_failed: "provisioning_failed";
+    readonly order_expired: "order_expired";
+    readonly order_canceled: "order_canceled";
+    readonly change_canceled: "change_canceled";
+    readonly change_expired: "change_expired";
+    readonly subscription_canceled: "subscription_canceled";
+    readonly usage_true_up: "usage_true_up";
+    readonly operator: "operator";
+};
+/**
+ * A reduction of an issued invoice; the original invoice amounts do not change. The credited amount is pre_payment_amount plus post_payment_amount. A paid part creates a refund, identified by refund_id, whose outcome may still be pending.
+ */
+export interface CreditNote {
+    id: string;
+    invoice_id: string;
+    currency: string;
+    issued_at: string;
+    status: CreditNoteStatus;
+    /**
+     * When this note was voided; null while issued.
+     * @nullable
+     */
+    voided_at: string | null;
+    /** The reduction of unpaid receivables. A void note no longer reduces what is due. */
+    pre_payment_amount: Money;
+    /** The credited part of payments already received; its refund may not have completed. */
+    post_payment_amount: Money;
+    /**
+     * The refund to the original payment sources; null when no paid amount was credited.
+     * @nullable
+     */
+    refund_id: string | null;
+    /** Why the note was issued. Notes for canceled, expired or failed orders carry the order's reason; `usage_true_up` returns a tier price reduction settled after the original invoice; `operator` was issued on request. */
+    reason: CreditNoteReason;
+}
+export interface CreditNoteItem {
+    id: string;
+    credit_note_id: string;
+    invoice_item_id: string;
+    pre_payment_amount: Money;
+    post_payment_amount: Money;
+}
+export interface CreditNoteList {
+    items: CreditNote[];
+    pagination: OffsetPagination;
+}
+export interface CreditNoteItemList {
+    items: CreditNoteItem[];
+    pagination: OffsetPagination;
+}
+/**
+ * Use balance_amount, credit_amount and gateway_amount, which also show a refund split between destinations.
+ * @deprecated
+ */
+export type RefundDestination = (typeof RefundDestination)[keyof typeof RefundDestination];
+export declare const RefundDestination: {
+    readonly balance: "balance";
+    readonly gateway: "gateway";
+};
+/**
+ * Summary of the parts in `transactions`.
+ *
+ * - `pending`: nothing has been returned yet, and at least one part is in progress.
+ * - `processing`: some parts have been returned, and at least one is still in progress.
+ * - `succeeded`: every part has been returned.
+ * - `failed`: no part is in progress and at least one has failed. What was returned is in
+ *   settled_amount.
+ *
+ * Returns to the balance and to credit grants complete shortly after the refund is made; a
+ * return to a payment method completes when the gateway confirms it.
+ */
+export type RefundStatus = (typeof RefundStatus)[keyof typeof RefundStatus];
+export declare const RefundStatus: {
+    readonly pending: "pending";
+    readonly processing: "processing";
+    readonly succeeded: "succeeded";
+    readonly failed: "failed";
+};
+/**
+ * Why the refund was made. New codes may be added; treat an unknown code as unspecified.
+ *
+ * - `provisioning_failed`: the purchase could not be delivered.
+ * - `order_expired`: the order expired after part of it was paid.
+ * - `order_canceled`: the order was canceled after part of it was paid.
+ * - `change_canceled`: a scheduled change was withdrawn after part of it was paid.
+ * - `change_expired`: a scheduled change could not take effect in time.
+ * - `subscription_canceled`: the unused value of a canceled subscription, under its refund terms.
+ * - `future_period_canceled`: a renewal that had not started was withdrawn.
+ * - `downgrade_difference`: after a downgrade, the remaining paid value, valued as refund policy `prorated`
+ *   describes, minus the new configuration's cost for the remaining time at the change item's
+ *   `refund_monthly_amount` and `refund_hourly_amount`.
+ * - `usage_true_up`: usage priced over the whole month cost less than was charged.
+ * - `payment_not_applied`: a payment arrived after its invoice could no longer be paid.
+ * - `operator`: made by the platform operator.
+ */
+export type RefundReason = (typeof RefundReason)[keyof typeof RefundReason];
+export declare const RefundReason: {
+    readonly provisioning_failed: "provisioning_failed";
+    readonly order_expired: "order_expired";
+    readonly order_canceled: "order_canceled";
+    readonly change_canceled: "change_canceled";
+    readonly change_expired: "change_expired";
+    readonly subscription_canceled: "subscription_canceled";
+    readonly future_period_canceled: "future_period_canceled";
+    readonly downgrade_difference: "downgrade_difference";
+    readonly usage_true_up: "usage_true_up";
+    readonly payment_not_applied: "payment_not_applied";
+    readonly operator: "operator";
+};
+export interface Refund {
+    transaction_id?: string;
+    cancellation_item_id?: string;
+    /** The refund split by original payment source, with each result. Unknown gateway results stay pending. */
+    transactions: Transaction[];
+    id: string;
+    billing_account_id?: number;
+    /** @nullable */
+    invoice_id?: string | null;
+    /**
+     * The order the refund belongs to: the order that caused it, such as a downgrade, otherwise the order of the refunded invoice. Null for refunds of top-ups and usage invoices.
+     * @nullable
+     */
+    order_id?: string | null;
+    /** The whole refund. Equals balance_amount plus credit_amount plus gateway_amount. */
+    amount: Money;
+    /** The part returned to the account balance. */
+    balance_amount: Money;
+    /** The part restored to the credit grants that paid for it. */
+    credit_amount: Money;
+    /** The part returned to the payment method it was paid with. */
+    gateway_amount: Money;
+    /** What has actually been returned. */
+    settled_amount?: Money;
+    currency: string;
+    /**
+     * Use balance_amount, credit_amount and gateway_amount, which also show a refund split between destinations.
+     * @deprecated
+     */
+    destination?: RefundDestination;
+    /**
+     * Summary of the parts in `transactions`.
+     *
+     * - `pending`: nothing has been returned yet, and at least one part is in progress.
+     * - `processing`: some parts have been returned, and at least one is still in progress.
+     * - `succeeded`: every part has been returned.
+     * - `failed`: no part is in progress and at least one has failed. What was returned is in
+     *   settled_amount.
+     *
+     * Returns to the balance and to credit grants complete shortly after the refund is made; a
+     * return to a payment method completes when the gateway confirms it.
+     */
+    status: RefundStatus;
+    /** When the last part was returned. Present with `succeeded`. */
+    settled_at?: string;
+    reason: RefundReason;
+    created_at: string;
+}
+export interface RefundList {
+    items: Refund[];
+    pagination: OffsetPagination;
+}
+/**
+ * The dimension values the rate was matched by, such as region and machine type.
+ */
+export type UsageChargeDimensions = {
+    [key: string]: string;
+};
+export interface UsageCharge {
+    subscription_id: string;
+    id: string;
+    project_id?: string;
+    /** The project and its current name. Absent when the project cannot be read; `project_id` still identifies it. */
+    project?: NamedIdentity | null;
+    product: Product;
+    /** Which resource this was charged for. Empty for charges not tied to one. */
+    resource_id?: string;
+    meter: ObjectIdentity;
+    unit?: string;
+    /** The dimension values the rate was matched by, such as region and machine type. */
+    dimensions?: UsageChargeDimensions;
+    window_start: string;
+    /** Exclusive. */
+    window_end: string;
+    /** Quantity used before allowances. */
+    gross_quantity?: string;
+    /** How much of that was covered by an allowance. */
+    deducted_quantity?: string;
+    /** The quantity charged: gross quantity less the part covered by allowances. */
+    quantity: string;
+    unit_amount?: Money;
+    amount: Money;
+    currency: string;
+    /**
+     * Present after the statement is closed and its invoice is issued.
+     * @nullable
+     */
+    invoice_id?: string | null;
+    /**
+     * Present after the statement is closed and its invoice is issued.
+     * @nullable
+     */
+    invoice_item_id?: string | null;
+    /** The statement this charge was collected into. */
+    statement_id?: string;
+}
+export interface UsageChargeList {
+    items: UsageCharge[];
+    pagination: OffsetPagination;
+}
+export type SubscriptionInterval = (typeof SubscriptionInterval)[keyof typeof SubscriptionInterval];
+export declare const SubscriptionInterval: {
+    readonly none: "none";
+    readonly day: "day";
+    readonly month: "month";
+    readonly year: "year";
+};
+/**
+ * An operation prevented on the subscription. `billing.subscriptions.use` stops the service. `renew` prevents renewal and paying a renewal order. `modify` prevents placing a change order. `cancel` prevents cancellation. `terminate` prevents immediate termination.
+ */
+export type SubscriptionRestriction = (typeof SubscriptionRestriction)[keyof typeof SubscriptionRestriction];
+export declare const SubscriptionRestriction: {
+    readonly billingsubscriptionsuse: "billing.subscriptions.use";
+    readonly billingsubscriptionsrenew: "billing.subscriptions.renew";
+    readonly billingsubscriptionsmodify: "billing.subscriptions.modify";
+    readonly billingsubscriptionscancel: "billing.subscriptions.cancel";
+    readonly billingsubscriptionsterminate: "billing.subscriptions.terminate";
+};
+/**
+ * Follows the items. `pending`: not yet accepted, paid or unpaid; its invoice shows whether payment is needed, and it can expire or be canceled. `accepted`: items are being set up. `completed`: every item was set up. `partially_completed`: some items were set up and the others failed or were canceled and refunded to their original payment sources. `failed`: no item was delivered and at least one failed; amounts collected for undelivered items are refunded. `canceled`: every item was withdrawn without delivery; collected amounts are returned to their original payment sources. No status by itself means the service was delivered.
+ */
+export type OrderStatus = (typeof OrderStatus)[keyof typeof OrderStatus];
+export declare const OrderStatus: {
+    readonly pending: "pending";
+    readonly accepted: "accepted";
+    readonly completed: "completed";
+    readonly partially_completed: "partially_completed";
+    readonly failed: "failed";
+    readonly canceled: "canceled";
+};
+export type ScheduledChangeInterval = (typeof ScheduledChangeInterval)[keyof typeof ScheduledChangeInterval];
+export declare const ScheduledChangeInterval: {
+    readonly day: "day";
+    readonly month: "month";
+    readonly year: "year";
+};
+/**
+ * The next accepted period-end change of the subscription: the target terms, applied at effective_at.
+ */
+export interface ScheduledChange {
+    order_id: string;
+    status: OrderStatus;
+    /** When the target terms take effect, normally the end of the current paid period. */
+    effective_at: string;
+    plan_id: string;
+    plan_name: string;
+    price_id: string;
+    quantity: string;
+    /** The target licensed renewal amount before tax. */
+    recurring_amount: string;
+    currency: string;
+    interval: ScheduledChangeInterval;
+    /** @minimum 1 */
+    interval_count: number;
+}
+/**
+ * `pending`: the order has not been accepted. `provisioning`: the owning service accepted the order and is delivering. `active`: delivery was confirmed; payment alone does not make a subscription active. `suspended`: service is stopped while a lien restricts its use. `canceled`: cancellation completed, or an undelivered purchase was canceled or failed. `terminated`: an operator or the owning service ended it immediately.
+ */
+export type SubscriptionStatus = (typeof SubscriptionStatus)[keyof typeof SubscriptionStatus];
+export declare const SubscriptionStatus: {
+    readonly pending: "pending";
+    readonly provisioning: "provisioning";
+    readonly active: "active";
+    readonly suspended: "suspended";
+    readonly canceled: "canceled";
+    readonly terminated: "terminated";
+};
+/**
+ * The dimension values of what was bought, such as region and instance type. Empty when the purchase gave none.
+ */
+export type SubscriptionDimensions = {
+    [key: string]: string;
+};
+/**
+ * A purchase that is billed, renewed and changed on its own, separate from the owning service's resource. A new
+ * recurring purchase creates a pending subscription for each order line; its ID is returned on the order item
+ * and stays the same through checkout, delivery, renewals and changes. A one-time purchase may create none.
+ *
+ * Pending and provisioning subscriptions grant no service. A subscription becomes provisioning when the owning
+ * service accepts the order, and active when the service confirms delivery, which sets started_at; payment
+ * changes neither. Licensed service periods start at delivery, and metered usage is charged as the service
+ * reports it. Canceling or failing an undelivered purchase cancels its subscriptions without starting a period.
+ * Renewals use recurring_amount and the agreed interval; paid periods keep their value.
+ *
+ * A shared capacity limit, such as a regional snapshot quota, has one subscription for the purchased quantity
+ * rather than one per item.
+ */
+export interface Subscription {
+    /** Whether new account discounts may apply to future renewals. A fixed operator renewal agreement disables automatic discounts; catalog repricing or a newly selected purchase agreement enables them. */
+    renewal_discounts_enabled?: boolean;
+    currency: string;
+    type: PriceType;
+    usage_type: UsageType;
+    /** The dimension values of what was bought, such as region and instance type. Empty when the purchase gave none. */
+    dimensions: SubscriptionDimensions;
+    interval: SubscriptionInterval;
+    /** @minimum 1 */
+    interval_count?: number;
+    /** The whole licensed subscription's renewal amount, after continuing discounts and before tax. A pending subscription shows base terms until paying the order fixes any new discount. Absent for metered and one-time subscriptions. */
+    recurring_amount?: string;
+    termination_policy?: TerminationPolicy;
+    refund_policy?: RefundPolicy;
+    order_item_id?: string;
+    coupon_id?: string;
+    coupon?: ObjectIdentity;
+    /** @minimum 0 */
+    discounted_renewals_remaining?: number;
+    /** The operations currently prevented on the subscription, sorted; it is suspended while this contains `billing.subscriptions.use`. */
+    restrictions?: SubscriptionRestriction[];
+    billing_cycle_anchor?: string;
+    cancellation?: SubscriptionCancellation;
+    /** The accepted period-end change scheduled for this subscription; null when there is none. */
+    scheduled_change?: ScheduledChange | null;
+    /**
+     * The saved payment method automatic renewal charges after balance and credits, before the account's default payment method. Set when a purchase, renewal or change is paid with a saved payment method. Used only while it belongs to the account paying the renewal.
+     * @nullable
+     */
+    default_payment_method_id?: string | null;
+    created_at?: string;
+    id: string;
+    /** The billing account that made the purchase. Renewals of a project subscription are charged to the project's current billing account. */
+    billing_account_id: number;
+    account: AccountIdentity;
+    product_id: ProductID;
+    /**
+     * The project it is for. Absent for an account-level purchase, such as a membership.
+     * @nullable
+     */
+    project_id?: string | null;
+    /** The project and its current name. Absent for an account-level purchase or when the project cannot be read; `project_id` still identifies it. */
+    project?: NamedIdentity | null;
+    product: Product;
+    plan_id: string;
+    plan_name: string;
+    price_id: string;
+    quantity: string;
+    /**
+     * When a licensed subscription renews or expires: the end of the last period bought, moved by renewing in advance. Null until the subscription becomes active, even when its purchase has been paid, and for metered subscriptions.
+     * @nullable
+     */
+    current_term_end?: string | null;
+    /**
+     * Start of the service period in effect now. Null when none is, including for metered subscriptions.
+     * @nullable
+     */
+    current_period_start?: string | null;
+    /**
+     * End of the service period in effect now; renewing in advance moves `current_term_end`, not this. Null when no period is in effect, including for metered subscriptions.
+     * @nullable
+     */
+    current_period_end?: string | null;
+    /** Whether a licensed subscription renews automatically. A metered subscription continues until it is canceled; for it this is true until a cancellation is requested, and cannot be set. */
+    auto_renew: boolean;
+    /** `pending`: the order has not been accepted. `provisioning`: the owning service accepted the order and is delivering. `active`: delivery was confirmed; payment alone does not make a subscription active. `suspended`: service is stopped while a lien restricts its use. `canceled`: cancellation completed, or an undelivered purchase was canceled or failed. `terminated`: an operator or the owning service ended it immediately. */
+    status: SubscriptionStatus;
+    /**
+     * When service started. Null until a new subscription becomes active, also after payment.
+     * @nullable
+     */
+    started_at?: string | null;
+    /** @nullable */
+    ended_at?: string | null;
+}
+export interface SubscriptionList {
+    items: Subscription[];
+    pagination: OffsetPagination;
+}
+export type RenewalPriceInterval = (typeof RenewalPriceInterval)[keyof typeof RenewalPriceInterval];
+export declare const RenewalPriceInterval: {
+    readonly day: "day";
+    readonly month: "month";
+    readonly year: "year";
+};
+export interface RenewalPrice {
+    termination_policy?: TerminationPolicy;
+    refund_policy?: RefundPolicy;
+    price_id: string;
+    /** How many periods one renewal covers. */
+    interval_count: number;
+    interval: RenewalPriceInterval;
+    /** What renewing for this term costs, for the quantity held. */
+    amount?: Money;
+    currency?: string;
+    /** The term the subscription renews at now; renewing for it keeps the agreed price. */
+    current: boolean;
+}
+export interface RenewalPriceList {
+    items: RenewalPrice[];
+    pagination: OffsetPagination;
+}
+/**
+ * The unit interval_count counts in.
+ */
+export type RenewRequestInterval = (typeof RenewRequestInterval)[keyof typeof RenewRequestInterval];
+export declare const RenewRequestInterval: {
+    readonly day: "day";
+    readonly month: "month";
+    readonly year: "year";
+};
+export interface RenewRequest {
+    /** The order ID, chosen by the caller. Creating it again conflicts; read the order after an unknown outcome. */
+    order_id: string;
+    /**
+     * How many further periods to buy, each at the price the subscription already renews at. To buy a longer term at its own price, give `interval` and `interval_count` instead.
+     * @minimum 1
+     */
+    periods?: number;
+    /**
+     * Renew for a term of this length instead, at the price currently sold for it. Give
+     * `interval` with it.
+     *
+     * Leaving both out renews at the price this item already bills at, which a later price
+     * change does not affect. Naming a term that differs from the current one is a fresh
+     * choice, so it is bought at today's price. Naming the current term changes nothing. A
+     * term sold at several prices that differ in termination policy is refused with 409
+     * `BILLING_RENEWAL_OPTION_AMBIGUOUS` unless `termination_policy` is given.
+     *
+     * List the terms on offer with the renewal prices operation.
+     * @minimum 1
+     */
+    interval_count?: number;
+    /** The unit interval_count counts in. */
+    interval?: RenewRequestInterval;
+    /** With `interval` and `interval_count`, chooses among prices of that term that differ in termination policy. */
+    termination_policy?: TerminationPolicy;
+    payment_method_id?: string;
+    /** Whether to pay from the balance, with or without `payment_method_id`. */
+    use_balance?: boolean;
+    /** Whether to pay from eligible credit grants before the balance. */
+    use_credits?: boolean;
+    return_url?: string;
+}
+/**
+ * As in renewing.
+ */
+export type RenewalOrderRequestInterval = (typeof RenewalOrderRequestInterval)[keyof typeof RenewalOrderRequestInterval];
+export declare const RenewalOrderRequestInterval: {
+    readonly day: "day";
+    readonly month: "month";
+    readonly year: "year";
+};
+/**
+ * The renewal's periods and price, chosen as in renewing.
+ */
+export interface RenewalOrderRequest {
+    /** The order ID, chosen by the caller. Creating it again conflicts; read the order after an unknown outcome. */
+    order_id: string;
+    /**
+     * As in renewing.
+     * @minimum 1
+     */
+    periods?: number;
+    /**
+     * As in renewing.
+     * @minimum 1
+     */
+    interval_count?: number;
+    /** As in renewing. */
+    interval?: RenewalOrderRequestInterval;
+    /** As in renewing. */
+    termination_policy?: TerminationPolicy;
+}
+export interface AutoRenewSet {
+    auto_renew: boolean;
+}
+/**
+ * `pending`: waiting to be set up. `completed`: set up, as confirmed by the service. `failed`: not set up; its amount was refunded to the original payment sources. `canceled`: withdrawn without delivery; any collected amount is returned. A completed item ends when its subscription is canceled.
+ */
+export type OrderItemStatus = (typeof OrderItemStatus)[keyof typeof OrderItemStatus];
+export declare const OrderItemStatus: {
+    readonly pending: "pending";
+    readonly completed: "completed";
+    readonly failed: "failed";
+    readonly canceled: "canceled";
+};
+/**
+ * `new` buys, `renew` extends a licensed subscription, `modify` changes a subscription's configuration or billing terms.
+ */
+export type OrderType = (typeof OrderType)[keyof typeof OrderType];
+export declare const OrderType: {
+    readonly new: "new";
+    readonly renew: "renew";
+    readonly modify: "modify";
+};
+/**
+ * When a plan change takes effect; `none` for anything that is not a change. A `period_end` order stays pending until the first period at the new price is paid. That period is invoiced shortly before the current paid period ends and starts when it ends; if the invoice is unpaid by then, the order is canceled and the subscription renews or ends as usual. A renewal in the meantime moves the change to the end of the renewed period.
+ */
+export type OrderChangeEffective = (typeof OrderChangeEffective)[keyof typeof OrderChangeEffective];
+export declare const OrderChangeEffective: {
+    readonly none: "none";
+    readonly immediate: "immediate";
+    readonly period_end: "period_end";
+};
+/**
+ * How it was paid. `payment_method_id` still names the payment method after it is removed.
+ */
+export interface PaidWith {
+    /**
+     * `balance` when the account's balance and credits covered it in full. Otherwise the method used
+     * with the gateway, such as `card`.
+     */
+    method_type: string;
+    /** The gateway that collected it. Absent when `method_type` is `balance`. */
+    payment_gateway?: string;
+    /** The saved payment method that was charged, when one was. */
+    payment_method_id?: string;
+    brand?: string;
+    last4?: string;
+}
+export type OrderItemInterval = (typeof OrderItemInterval)[keyof typeof OrderItemInterval];
+export declare const OrderItemInterval: {
+    readonly none: "none";
+    readonly day: "day";
+    readonly month: "month";
+    readonly year: "year";
+};
+export type OrderItemConfiguration = {
+    [key: string]: unknown;
+};
+/**
+ * The dimension values the line was bought with, such as region and instance type. Empty when the purchase gave none.
+ */
+export type OrderItemDimensions = {
+    [key: string]: string;
+};
+/**
+ * The purchase terms frozen at placement. Monetary fields come from the order's invoice lines and are zero without an immediate charge, such as for a metered purchase. Later catalog changes do not reprice the line. A new service purchase has its pending subscription from placement.
+ */
+export interface OrderItem {
+    /** Whether new account discounts may apply to future renewals. A fixed operator renewal agreement disables automatic discounts; catalog repricing or a newly selected purchase agreement enables them. */
+    renewal_discounts_enabled?: boolean;
+    /** Financial lines produced by this purchase item, including setup charges. */
+    invoice_item_ids?: string[];
+    /** @minimum 0 */
+    position?: number;
+    configuration?: OrderItemConfiguration;
+    /** The Billing subscription: the new pending subscription of a recurring purchase, or the existing one renewed or changed, which keeps its ID. Absent for a purchase without a subscription. */
+    subscription_id?: string;
+    interval: OrderItemInterval;
+    /** @minimum 1 */
+    interval_count?: number;
+    termination_policy?: TerminationPolicy;
+    refund_policy?: RefundPolicy;
+    /**
+     * Recurring licensed items only: the plan's one-month licensed price for this item's quantity, before tax and frozen at purchase, used to value time under a prorated refund or a downgrade. Null when the plan has no licensed period shorter than the one bought.
+     * @nullable
+     */
+    refund_monthly_amount?: string | null;
+    /**
+     * Recurring licensed items only, the plan's metered hourly price for this item's quantity before tax, frozen at purchase, used for time used short of a full month. Null when the licensed price has no meter.
+     * @nullable
+     */
+    refund_hourly_amount?: string | null;
+    recurring_amount?: string;
+    setup_amount?: string;
+    type: PriceType;
+    usage_type: UsageType;
+    /** The dimension values the line was bought with, such as region and instance type. Empty when the purchase gave none. */
+    dimensions: OrderItemDimensions;
+    /** Total tax after discounts, including any tax already included in the price. */
+    tax_amount?: string;
+    /** The part of tax_amount already included in gross_amount; it is not charged again. */
+    tax_included_amount?: string;
+    id: string;
+    order_id?: string;
+    price_id: string;
+    product_id?: ProductID;
+    product?: Product;
+    /** Which plan was bought. */
+    plan_id: string;
+    /** The name when bought. */
+    plan_name: string;
+    quantity: string;
+    /** The unit amount of the price the line is charged under. Absent for a tiered price, and for an immediate change, which is charged as `gross_amount` describes. */
+    unit_amount?: Money;
+    /**
+     * Before discounts and setup fees: the price applied to the quantity, `unit_amount` times `quantity` for a per-
+     * unit price, raised by any minimum charge. For an immediate upgrade it is the new price for the rest of the
+     * paid period minus the amount paid for that time; a downgrade, or a change between equal period prices, charges
+     * nothing.
+     *
+     * Under an inclusive tax rate it includes tax, shown in `tax_included_amount`, except for a renewal at agreed
+     * terms, whose amount excludes tax.
+     */
+    gross_amount?: Money;
+    /** The reduction on this line, from the order's coupon and, for a renewal at agreed terms, from the subscription's carried discount. With a carried discount, `gross_amount` is `unit_amount` times `quantity`, except when the renewal order also uses an account coupon or the tax rate is inclusive: then `gross_amount` is the agreed amount, which already reflects the carried discount. */
+    discount_amount?: Money;
+    /** `gross_amount` less `discount_amount`. */
+    amount?: Money;
+    currency: string;
+    /**
+     * The start of the service period this line paid for. Fixed at placement for renewals and period-end changes, and for a licensed line of a new purchase when its invoice is paid. Absent for metered and one-time lines.
+     * @nullable
+     */
+    period_start?: string | null;
+    /**
+     * The end of that service period, exclusive.
+     * @nullable
+     */
+    period_end?: string | null;
+    status: OrderItemStatus;
+}
+/**
+ * A recorded purchase with its invoice from placement; a zero-total invoice, such as for a metered purchase, is issued and paid at placement in either checkout mode. Until checkout_confirmed_at is set, the invoice is a draft at base prices: paying it fixes the discount and amount, issues it and collects it, and the order cannot be accepted before then. Coupon fields describe the discount fixed then and are absent before. Payment and acceptance do not mean the resources were delivered.
+ */
+export interface Order {
+    coupon_id?: string;
+    coupon?: ObjectIdentity;
+    promotion_code_id?: string;
+    /** The promotion code applied. Absent for an account discount. */
+    promotion_code?: string;
+    /** The order's invoice, the same as invoice.id. */
+    invoice_id: string;
+    invoice: InvoiceSummary;
+    /** How the order was paid. Absent until it is paid. */
+    paid_with?: PaidWith;
+    account?: AccountIdentity;
+    change_effective_at?: string;
+    id: string;
+    /**
+     * The project it was bought for. Absent for an account-level purchase, such as a membership.
+     * @nullable
+     */
+    project_id?: string | null;
+    /** The project and its current name. Absent for an account-level purchase or when the project cannot be read; `project_id` still identifies it. */
+    project?: NamedIdentity | null;
+    /** The billing account the order was placed with, unchanged when the project is later linked to another account. While it is suspended or closed, the order cannot be accepted, and a period-end change's invoice is not issued and the change is called off when the current period ends; such requests fail with `BILLING_ACCOUNT_UNAVAILABLE`. */
+    billing_account_id?: number;
+    currency: string;
+    /** `new` buys, `renew` extends a licensed subscription, `modify` changes a subscription's configuration or billing terms. */
+    type: OrderType;
+    status: OrderStatus;
+    /** When a plan change takes effect; `none` for anything that is not a change. A `period_end` order stays pending until the first period at the new price is paid. That period is invoiced shortly before the current paid period ends and starts when it ends; if the invoice is unpaid by then, the order is canceled and the subscription renews or ends as usual. A renewal in the meantime moves the change to the end of the renewed period. */
+    change_effective?: OrderChangeEffective;
+    /**
+     * Acceptance deadline; a pending order expires after it.
+     * @nullable
+     */
+    expires_at?: string | null;
+    /**
+     * When the discount and amount were fixed: at placement for automatic checkout or a zero total, otherwise when the invoice was first paid. Null while a deferred order awaits payment.
+     * @nullable
+     */
+    checkout_confirmed_at?: string | null;
+    created_at: string;
+    /** What was bought. */
+    items: OrderItem[];
+}
+export interface OrderList {
+    items: Order[];
+    pagination: OffsetPagination;
+}
+/**
+ * `scheduled` before valid_from, `active` within the validity, `expired` after valid_until, or `voided` once withdrawn.
+ */
+export type DiscountStatus = (typeof DiscountStatus)[keyof typeof DiscountStatus];
+export declare const DiscountStatus: {
+    readonly scheduled: "scheduled";
+    readonly active: "active";
+    readonly expired: "expired";
+    readonly voided: "voided";
+};
+export type DiscountType = (typeof DiscountType)[keyof typeof DiscountType];
+export declare const DiscountType: {
+    readonly percentage: "percentage";
+    readonly fixed_amount: "fixed_amount";
+    readonly price_override: "price_override";
+    readonly free_setup: "free_setup";
+};
+/**
+ * Whether the discount continues on renewals: `once` applies only to the purchase or renewal using the coupon, `recurring` for `frequency_duration` periods including the first, `forever` on every renewal.
+ */
+export type DiscountFrequency = (typeof DiscountFrequency)[keyof typeof DiscountFrequency];
+export declare const DiscountFrequency: {
+    readonly once: "once";
+    readonly recurring: "recurring";
+    readonly forever: "forever";
+};
+/**
+ * A coupon held by the account for a period, applying without a code to the purchases and metered usage it covers.
+ */
+export interface Discount {
+    min_amount?: string;
+    billing_account_id?: number;
+    coupon_id: string;
+    promotion_code_id?: string;
+    /** `scheduled` before valid_from, `active` within the validity, `expired` after valid_until, or `voided` once withdrawn. */
+    status: DiscountStatus;
+    voided_at?: string;
+    type: DiscountType;
+    /** Whether the discount continues on renewals: `once` applies only to the purchase or renewal using the coupon, `recurring` for `frequency_duration` periods including the first, `forever` on every renewal. */
+    frequency?: DiscountFrequency;
+    /** @minimum 1 */
+    frequency_duration?: number;
+    id: string;
+    name?: string;
+    /** For a percentage discount, out of one hundred. */
+    percent_off?: string;
+    amount?: Money;
+    /** Caps a percentage discount. */
+    max_discount?: Money;
+    currency?: string;
+    /** What it may pay for. Absent means anything on the account, including setup fees and usage. */
+    applies_to: Applicability;
+    /** Restricted to your first purchase of anything it applies to. */
+    first_purchase_only?: boolean;
+    valid_from?: string;
+    /**
+     * Absent follows the coupon's own validity.
+     * @nullable
+     */
+    valid_until?: string | null;
+}
+export interface DiscountList {
+    items: Discount[];
+    pagination: OffsetPagination;
+}
+export interface OrderItemList {
+    items: OrderItem[];
+    pagination: OffsetPagination;
+}
+/**
+ * Whether the quantity was paid for or granted free; both are consumed the same way.
+ */
+export type AllowanceCategory = (typeof AllowanceCategory)[keyof typeof AllowanceCategory];
+export declare const AllowanceCategory: {
+    readonly paid: "paid";
+    readonly promotional: "promotional";
+};
+/**
+ * Exact values for a subset of the meter's dimensions. Only usage with these values is deducted;
+ * omitted dimensions are not restricted.
+ */
+export type AllowanceDimensions = {
+    [key: string]: string;
+};
+export type AllowanceStatus = (typeof AllowanceStatus)[keyof typeof AllowanceStatus];
+export declare const AllowanceStatus: {
+    readonly active: "active";
+    readonly depleted: "depleted";
+    readonly expired: "expired";
+    readonly voided: "voided";
+};
+export interface Allowance {
+    /** Optional issuance key, unique within this billing account. */
+    idempotency_key?: string;
+    subscription_id?: string;
+    id: string;
+    billing_account_id?: number;
+    product: Product;
+    meter: ObjectIdentity;
+    /** The unit it is counted in, such as `MiB`. */
+    unit?: string;
+    /** Whether the quantity was paid for or granted free; both are consumed the same way. */
+    category: AllowanceCategory;
+    /**
+     * Exact values for a subset of the meter's dimensions. Only usage with these values is deducted;
+     * omitted dimensions are not restricted.
+     */
+    dimensions: AllowanceDimensions;
+    name: string;
+    /** How much was granted. */
+    quantity: string;
+    /** How much is left. */
+    remaining_quantity: string;
+    /** Lower values are consumed first; at equal priority, earlier expiry and then earlier issuance. */
+    priority?: number;
+    status: AllowanceStatus;
+    valid_from: string;
+    /**
+     * When the allowance lapses; unused quantity is lost. Absent when it does not expire.
+     * @nullable
+     */
+    valid_until?: string | null;
+}
+export interface AllowanceList {
+    items: Allowance[];
+    pagination: OffsetPagination;
+}
+/**
+ * Derived from the validity period. scheduled means valid_from has not yet arrived.
+ */
+export type FeatureGrantStatus = (typeof FeatureGrantStatus)[keyof typeof FeatureGrantStatus];
+export declare const FeatureGrantStatus: {
+    readonly scheduled: "scheduled";
+    readonly active: "active";
+    readonly expired: "expired";
+    readonly voided: "voided";
+};
+export interface FeatureGrant {
+    id: string;
+    billing_account_id: number;
+    product: Product;
+    feature: ObjectIdentity;
+    name: string;
+    valid_from: string;
+    /**
+     * Null means the grant does not expire.
+     * @nullable
+     */
+    valid_until: string | null;
+    status: FeatureGrantStatus;
+}
+export interface FeatureGrantList {
+    items: FeatureGrant[];
+    pagination: OffsetPagination;
+}
+export interface Entitlement {
+    product: Product;
+    feature: ObjectIdentity;
+    name?: string;
+    enabled: boolean;
+    /**
+     * When the providing subscription ends. Absent for a metered subscription.
+     * @nullable
+     */
+    expires_at?: string | null;
+}
+export interface EntitlementList {
+    items: Entitlement[];
+    pagination: OffsetPagination;
+}
+export interface ProductList {
+    items: Product[];
+    pagination: OffsetPagination;
+}
+export interface PlanFeature {
+    feature: ObjectIdentity;
+    name: string;
+}
+export interface Plan {
+    /** False once archived. An archived plan cannot be bought until it is active again. */
+    active: boolean;
+    lookup_key?: string;
+    product: Product;
+    features: PlanFeature[];
+    id: string;
+    product_id: ProductID;
+    name: string;
+    description?: string;
+}
+export interface PlanList {
+    items: Plan[];
+    pagination: OffsetPagination;
+}
+/**
+ * How a ladder is walked: `graduated` charges each band at its own rate, `volume` charges everything at the rate of the band the total falls in. `none` when not tiered.
+ */
+export type PriceTiersMode = (typeof PriceTiersMode)[keyof typeof PriceTiersMode];
+export declare const PriceTiersMode: {
+    readonly none: "none";
+    readonly graduated: "graduated";
+    readonly volume: "volume";
+};
+export type PriceInterval = (typeof PriceInterval)[keyof typeof PriceInterval];
+export declare const PriceInterval: {
+    readonly none: "none";
+    readonly day: "day";
+    readonly month: "month";
+    readonly year: "year";
+};
+export interface Tier {
+    /**
+     * The band's inclusive upper bound; null for the last band.
+     * @nullable
+     */
+    up_to?: string | null;
+    unit_amount: Money;
+    /** Charged once when this band is reached, in addition to the per-unit amount. */
+    flat_amount?: Money;
+}
+export interface Price {
+    rate_card?: ObjectIdentity;
+    lookup_key?: string;
+    product: Product;
+    plan: ObjectIdentity;
+    /** For a metered price with its own amounts, the meter it charges. For a licensed price, the meter its quantity is held on. Absent otherwise. */
+    meter_id?: string;
+    meter?: ObjectIdentity;
+    unit_quantity: string;
+    /** False once archived. An archived price cannot be bought until it is active again. */
+    active: boolean;
+    termination_policy?: TerminationPolicy;
+    refund_policy?: RefundPolicy;
+    product_id?: ProductID;
+    id: string;
+    plan_id: string;
+    currency: string;
+    type: PriceType;
+    usage_type: UsageType;
+    /** Absent when the price delegates to a rate card, where the rate depends on attributes such as region or machine type. */
+    billing_scheme?: BillingScheme;
+    /** Present for `per_unit`. */
+    unit_amount?: Money;
+    /** How a ladder is walked: `graduated` charges each band at its own rate, `volume` charges everything at the rate of the band the total falls in. `none` when not tiered. */
+    tiers_mode?: PriceTiersMode;
+    /** Present for `tiered`, in ascending order. */
+    tiers?: Tier[];
+    /** Present when the price delegates to a rate card, the price list its rates are read from. */
+    rate_card_id?: string;
+    /** The smallest quantity that can be bought. Absent means no lower bound. */
+    min_quantity?: string;
+    /** The largest quantity that may be bought; absent when there is no limit. A larger quantity is refused with `BILLING_PRICE_INVALID` and `field` `max_quantity`. */
+    max_quantity?: string;
+    /** Quantities must be a multiple of this. Absent means any quantity within the bounds. */
+    quantity_step?: string;
+    /** For recurring licensed prices, how many interval units one period covers. */
+    interval_count?: number;
+    interval: PriceInterval;
+    setup_fee?: Money;
+}
+export interface PriceList {
+    items: Price[];
+    pagination: OffsetPagination;
+}
+/**
+ * The dimension values this rate applies to, such as region and machine type.
+ */
+export type RateDimensions = {
+    [key: string]: string;
+};
+/**
+ * Licensed rates only, the period the amount buys; `none` for metered rates.
+ */
+export type RateInterval = (typeof RateInterval)[keyof typeof RateInterval];
+export declare const RateInterval: {
+    readonly none: "none";
+    readonly day: "day";
+    readonly month: "month";
+    readonly year: "year";
+};
+/**
+ * `graduated` charges each band at its own rate; `volume` charges everything at the rate of the band the total lands in. `none` for a `per_unit` rate.
+ */
+export type RateTiersMode = (typeof RateTiersMode)[keyof typeof RateTiersMode];
+export declare const RateTiersMode: {
+    readonly none: "none";
+    readonly graduated: "graduated";
+    readonly volume: "volume";
+};
+export interface Rate {
+    meter: ObjectIdentity;
+    /** The unit readings are reported in, such as `core-second`. */
+    unit?: string;
+    /** The dimension values this rate applies to, such as region and machine type. */
+    dimensions: RateDimensions;
+    billing_scheme: BillingScheme;
+    /** `metered` prices usage; `licensed` prices holding a quantity for one period. */
+    usage_type: UsageType;
+    /** Licensed rates only, the period the amount buys; `none` for metered rates. */
+    interval: RateInterval;
+    /** @nullable */
+    interval_count?: number | null;
+    /** `graduated` charges each band at its own rate; `volume` charges everything at the rate of the band the total lands in. `none` for a `per_unit` rate. */
+    tiers_mode: RateTiersMode;
+    /** Present for `per_unit`. Tiered rates carry their amounts on the tiers. */
+    unit_amount?: Money;
+    /** Present for a tiered rate, in ascending order. */
+    tiers?: Tier[];
+    /** How many measured units one amount covers; an hourly rate on a per-second meter is `"3600"`. */
+    unit_quantity?: string;
+    currency: string;
+    effective_from: string;
+    /** @nullable */
+    effective_to?: string | null;
+}
+export interface RateList {
+    items: Rate[];
+    pagination: OffsetPagination;
+}
+export type QuoteItemInputInterval = (typeof QuoteItemInputInterval)[keyof typeof QuoteItemInputInterval];
+export declare const QuoteItemInputInterval: {
+    readonly none: "none";
+    readonly day: "day";
+    readonly month: "month";
+    readonly year: "year";
+};
+/**
+ * The dimension values the rate depends on, such as region, instance type or token kind: those of the usage for a metered estimate, and those of what is bought for a licensed price on a rate card. Required whenever the price uses a rate card; prices with their own amounts ignore them. Every key the meter declares must be given. A combination no rate covers is refused rather than priced at zero.
+ */
+export type QuoteItemInputDimensions = {
+    [key: string]: string;
+};
+/**
+ * Identify a price, or select one for a plan; give each resource's ID or lookup key, never both, and product_id with lookup keys. For a metered price, a meter or duration_seconds requests a usage estimate, which cannot be combined with a promotion code and is not a checkout amount. Without one, a metered item includes only any setup charge.
+ */
+export interface QuoteItemInput {
+    /**
+     * @minLength 1
+     * @maxLength 128
+     */
+    price_lookup_key?: string;
+    /**
+     * @minLength 1
+     * @maxLength 128
+     */
+    plan_lookup_key?: string;
+    price_id?: string;
+    product_id?: ProductID;
+    plan_id?: string;
+    /** Narrows the selection when a plan offers more than one price type. */
+    price_type?: PriceType;
+    /** Narrows the selection when a plan offers more than one usage type. */
+    usage_type?: UsageType;
+    interval?: QuoteItemInputInterval;
+    /** @minimum 1 */
+    interval_count?: number;
+    /** Selects among licensed prices with otherwise identical billing terms. Ambiguous terms are refused instead of choosing a price arbitrarily. */
+    termination_policy?: TerminationPolicy;
+    /** @pattern ^(?:(?:[1-9][0-9]{0,27}|0(?:[1-9][0-9]{0,26}|0(?:[1-9][0-9]{0,25}|0(?:[1-9][0-9]{0,24}|0(?:[1-9][0-9]{0,23}|0(?:[1-9][0-9]{0,22}|0(?:[1-9][0-9]{0,21}|0(?:[1-9][0-9]{0,20}|0(?:[1-9][0-9]{0,19}|0(?:[1-9][0-9]{0,18}|0(?:[1-9][0-9]{0,17}|0(?:[1-9][0-9]{0,16}|0(?:[1-9][0-9]{0,15}|0(?:[1-9][0-9]{0,14}|0(?:[1-9][0-9]{0,13}|0(?:[1-9][0-9]{0,12}|0(?:[1-9][0-9]{0,11}|0(?:[1-9][0-9]{0,10}|0(?:[1-9][0-9]{0,9}|0(?:[1-9][0-9]{0,8}|0(?:[1-9][0-9]{0,7}|0(?:[1-9][0-9]{0,6}|0(?:[1-9][0-9]{0,5}|0(?:[1-9][0-9]{0,4}|0(?:[1-9][0-9]{0,3}|0(?:[1-9][0-9]{0,2}|0(?:[1-9][0-9]{0,1}|0[1-9])))))))))))))))))))))))))))([.][0-9]{1,10})?|0{1,28}[.](?:[1-9][0-9]{0,9}|0(?:[1-9][0-9]{0,8}|0(?:[1-9][0-9]{0,7}|0(?:[1-9][0-9]{0,6}|0(?:[1-9][0-9]{0,5}|0(?:[1-9][0-9]{0,4}|0(?:[1-9][0-9]{0,3}|0(?:[1-9][0-9]{0,2}|0(?:[1-9][0-9]{0,1}|0[1-9]))))))))))$ */
+    quantity: string;
+    meter_id?: string;
+    /**
+     * @minLength 1
+     * @maxLength 128
+     */
+    meter_lookup_key?: string;
+    /** The dimension values the rate depends on, such as region, instance type or token kind: those of the usage for a metered estimate, and those of what is bought for a licensed price on a rate card. Required whenever the price uses a rate card; prices with their own amounts ignore them. Every key the meter declares must be given. A combination no rate covers is refused rather than priced at zero. */
+    dimensions?: QuoteItemInputDimensions;
+    /** For a metered estimate, how long to price for, in seconds; the priced quantity is `quantity` times this duration. */
+    duration_seconds?: number;
+}
+/**
+ * The values of the meter's presentation dimensions, present only when grouped by meter.
+ */
+export type SpendRowDimensions = {
+    [key: string]: string;
+};
+export interface SpendRow {
+    product?: Product;
+    plan_id?: string;
+    plan_name?: string;
+    /** Present only when grouped by resource. */
+    resource_id?: string;
+    /** Present only when grouped by meter. */
+    meter?: ObjectIdentity;
+    /** Present only when grouped by meter. */
+    unit?: string;
+    /** Net usage quantity, present only when grouped by meter. */
+    quantity?: string;
+    /** The values of the meter's presentation dimensions, present only when grouped by meter. */
+    dimensions?: SpendRowDimensions;
+    amount: Money;
+    currency: string;
+}
+export interface SpendRowList {
+    items: SpendRow[];
+    /** The total over all matching groups, not only the page returned. */
+    total: Money;
+    currency: string;
+    pagination: OffsetPagination;
+}
+export type ActiveResourceDimensions = {
+    [key: string]: string;
+};
+export type ActiveResourceStatus = (typeof ActiveResourceStatus)[keyof typeof ActiveResourceStatus];
+export declare const ActiveResourceStatus: {
+    readonly active: "active";
+    readonly suspended: "suspended";
+    readonly closing: "closing";
+    readonly closed: "closed";
+};
+/**
+ * A resource charged continuously by the second.
+ */
+export interface ActiveResource {
+    id: string;
+    ended_at?: string;
+    suspended_at?: string;
+    state_changed_at?: string;
+    /** The metered subscription charged for this metering record. */
+    subscription_id: string;
+    resource_id: string;
+    product: Product;
+    /** The resource type, as the owning service names it. */
+    resource_type?: string;
+    meter: ObjectIdentity;
+    unit?: string;
+    /** How much is held, such as cores, MiB or cards; not how much was used. */
+    quantity: string;
+    dimensions?: ActiveResourceDimensions;
+    status: ActiveResourceStatus;
+    started_at: string;
+    project_id?: string;
+    /** Usage has been generated up to this boundary; it says nothing about invoicing or payment. */
+    usage_generated_until: string;
+}
+export interface ActiveResourceList {
+    items: ActiveResource[];
+    pagination: OffsetPagination;
+}
+/**
+ * An estimate of the refundable value of an order or selected items; nothing is canceled or refunded.
+ */
+export interface OrderRefundQuoteInput {
+    order_id: string;
+    /**
+     * Estimate only these items. Omit to estimate the whole order. Every item must belong to the order.
+     * @minItems 1
+     * @maxItems 100
+     */
+    order_item_ids?: string[];
+}
+/**
+ * Quote exactly one target for the billing account: proposed items, an existing order, renewals, a cancellation or an order refund. Promotion codes apply only to proposed items or an existing order. An invalid combination fails with `BILLING_PURCHASE_INVALID` and the field.
+ */
+export interface QuoteRequest {
+    /**
+     * The billing account to price for; it must be yours. Existing orders must have been placed with it, and renewals and cancellations must currently be paid by it.
+     * @minimum 1
+     */
+    billing_account_id: number;
+    /**
+     * A proposed purchase priced in the account's currency. Metered items may include usage estimates, which are not checkout amounts.
+     * @minItems 1
+     * @maxItems 100
+     */
+    items?: QuoteItemInput[];
+    /** Preview paying this order. Its recorded terms supply every line, and an order whose terms are fixed returns its recorded amounts. The order does not change. */
+    order_id?: string;
+    /**
+     * Preview renewing these subscriptions, each at most once; each entry is a separate renewal order. To preview a promotion code, create a renewal order and quote it by order_id.
+     * @minItems 1
+     * @maxItems 100
+     */
+    renewals?: QuoteRenewal[];
+    cancellation?: QuoteCancellation;
+    /**
+     * @minLength 1
+     * @maxLength 64
+     */
+    promotion_code?: string;
+    refund?: OrderRefundQuoteInput;
+}
+/**
+ * How tax applies to the customer, as in Stripe: `none` taxes normally, `exempt` charges no tax, `reverse` charges no tax under the reverse-charge mechanism, stated on invoices. Only operators change it.
+ */
+export type ContactTaxExempt = (typeof ContactTaxExempt)[keyof typeof ContactTaxExempt];
+export declare const ContactTaxExempt: {
+    readonly none: "none";
+    readonly exempt: "exempt";
+    readonly reverse: "reverse";
+};
+/**
+ * A contact of a billing account with one address. An account can hold several; a contact is not a login.
+ */
+export interface Contact {
+    id: string;
+    billing_account_id: number;
+    /**
+     * @minLength 1
+     * @maxLength 255
+     */
+    name: string;
+    /** @maxLength 255 */
+    legal_name?: string;
+    /** @maxLength 255 */
+    email?: string;
+    /** @maxLength 64 */
+    tax_id?: string;
+    /** @maxLength 255 */
+    address_line1?: string;
+    /** @maxLength 255 */
+    address_line2?: string;
+    /** @maxLength 128 */
+    address_city?: string;
+    /** @maxLength 128 */
+    address_state?: string;
+    /** @maxLength 32 */
+    address_postal_code?: string;
+    /** @pattern ^([A-Z]{2})?$ */
+    address_country?: string;
+    /** How tax applies to the customer, as in Stripe: `none` taxes normally, `exempt` charges no tax, `reverse` charges no tax under the reverse-charge mechanism, stated on invoices. Only operators change it. */
+    tax_exempt: ContactTaxExempt;
+    active: boolean;
+    created_at: string;
+}
+export interface ContactCreate {
+    /**
+     * @minLength 1
+     * @maxLength 255
+     */
+    name: string;
+    /** @maxLength 255 */
+    legal_name?: string;
+    /** @maxLength 255 */
+    email?: string;
+    /** @maxLength 64 */
+    tax_id?: string;
+    /** @maxLength 255 */
+    address_line1?: string;
+    /** @maxLength 255 */
+    address_line2?: string;
+    /** @maxLength 128 */
+    address_city?: string;
+    /** @maxLength 128 */
+    address_state?: string;
+    /** @maxLength 32 */
+    address_postal_code?: string;
+    /** @pattern ^([A-Z]{2})?$ */
+    address_country?: string;
+}
+export interface ContactUpdate {
+    /**
+     * @minLength 1
+     * @maxLength 255
+     */
+    name?: string;
+    /** @maxLength 255 */
+    legal_name?: string;
+    /** @maxLength 255 */
+    email?: string;
+    /** @maxLength 64 */
+    tax_id?: string;
+    /** @maxLength 255 */
+    address_line1?: string;
+    /** @maxLength 255 */
+    address_line2?: string;
+    /** @maxLength 128 */
+    address_city?: string;
+    /** @maxLength 128 */
+    address_state?: string;
+    /** @maxLength 32 */
+    address_postal_code?: string;
+    /** @pattern ^([A-Z]{2})?$ */
+    address_country?: string;
+    active?: boolean;
+}
+export interface ContactList {
+    items: Contact[];
+    pagination: OffsetPagination;
+}
+export interface CancelSubscriptionRequest {
+    mode: TerminationPolicy;
+    /** For immediate cancellation, the quoted whole-second refund basis. Now when omitted. */
+    proration_date?: string;
+    /** The cancellation quote's refundable amount, including an explicit zero. */
+    expected_refundable_amount: Money & string;
+    /** @maxLength 1024 */
+    reason?: string;
+}
+export interface StatementAmounts {
+    subtotal: Money;
+    discount_amount: Money;
+    tax_amount: Money;
+    total: Money;
+}
+/**
+ * One billing account's usage billing for one UTC calendar month, summed over its statements. Not payable itself; each statement's invoice is collected on its own.
+ */
+export interface MonthlyStatement {
+    billing_account_id: number;
+    currency: string;
+    period_start: string;
+    period_end: string;
+    /** True after the period's final closing, which applies the month's minimum charges. Usage priced later is billed in supplement statements and added here. */
+    finalized: boolean;
+    finalized_at?: string;
+    /** Statements of the period, including the open one. */
+    statement_count: number;
+    billed: StatementAmounts;
+    credited_amount: Money;
+    unbilled?: StatementAmounts;
+    credit_applied: Money;
+    amount_paid: Money;
+    amount_due: Money;
+    amount_refunded: Money;
+}
+export interface MonthlyStatementList {
+    items: MonthlyStatement[];
+    pagination: OffsetPagination;
+}
+export type StatementStatus = (typeof StatementStatus)[keyof typeof StatementStatus];
+export declare const StatementStatus: {
+    readonly open: "open";
+    readonly closed: "closed";
+};
+/**
+ * `interim`: a closing before the period's usage is final, without minimum charges. `final`: the first closing after the period ended and its late usage was settled, applying the period's minimum charges. `supplement`: a closing after the final one, for usage priced late. An open statement is interim.
+ */
+export type StatementType = (typeof StatementType)[keyof typeof StatementType];
+export declare const StatementType: {
+    readonly interim: "interim";
+    readonly final: "final";
+    readonly supplement: "supplement";
+};
+/**
+ * An account's consumption for one billing period up to one closing. Usage is invoiced after every settlement run, about hourly: each closing issues an invoice for the usage priced since the previous one and collects it from credits and balance, and later usage goes into the next statement of the same period. A closed statement does not change. The period's consumption is the sum of its statements.
+ */
+export interface Statement {
+    id: string;
+    billing_account_id: number;
+    currency: string;
+    period_start: string;
+    period_end: string;
+    /** Increases with each closing of the period. */
+    sequence: number;
+    status: StatementStatus;
+    type: StatementType;
+    /** True while the statement is open. The estimate prices the period's usage so far at tier prices and adds tax for the current invoice contact. Minimum charges are added at the period's final closing, and a tier reduction larger than this statement's charges is credited to the period's earlier invoices at closing. */
+    estimated: boolean;
+    amounts: StatementAmounts;
+    closed_at?: string;
+    /** The invoice issued at this closing, when it produced one. */
+    invoice_id?: string;
+    created_at: string;
+    calculated_at?: string;
+    credited_amount: Money;
+}
+export interface StatementList {
+    items: Statement[];
+    pagination: OffsetPagination;
+}
+/**
+ * The values of the meter's presentation dimensions, such as the model and token kind. Included only when grouping by meter, which splits each meter by these values.
+ */
+export type StatementItemDimensions = {
+    [key: string]: string;
+};
+export interface StatementItem {
+    project_id?: string;
+    product_id?: string;
+    meter_id?: string;
+    unit?: string;
+    /** The values of the meter's presentation dimensions, such as the model and token kind. Included only when grouping by meter, which splits each meter by these values. */
+    dimensions?: StatementItemDimensions;
+    /** Net usage quantity. Included only when grouping by meter. */
+    quantity?: string;
+    deducted_quantity?: string;
+    amount: Money;
+}
+export type StatementSummaryGroupBy = (typeof StatementSummaryGroupBy)[keyof typeof StatementSummaryGroupBy];
+export declare const StatementSummaryGroupBy: {
+    readonly project: "project";
+    readonly product: "product";
+    readonly meter: "meter";
+};
+export interface StatementSummary {
+    statement_id: string;
+    currency: string;
+    estimated: boolean;
+    calculated_at?: string;
+    group_by: StatementSummaryGroupBy;
+    items: StatementItem[];
+    pagination: OffsetPagination;
+}
+/**
+ * The request conflicts with the current state of the service. The codes are described where they apply.
+ */
+export type ConflictResponse = Error;
+export type ListApiKeysParams = {
+    /**
+     * Items returned in this page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    limit?: number;
+    /**
+     * Items to skip. Defaults to 0; at most 10000.
+     * @minimum 0
+     * @maximum 10000
+     */
+    offset?: number;
+    /**
+     * Restricts the result to the specified status. Every status is returned while this is absent
+     */
+    status?: ListApiKeysStatus;
+};
+export type ListApiKeysStatus = (typeof ListApiKeysStatus)[keyof typeof ListApiKeysStatus];
+export declare const ListApiKeysStatus: {
+    readonly active: "active";
+    readonly disabled: "disabled";
+    readonly revoked: "revoked";
+};
+export type ListRequestsParams = {
+    /**
+     * Start of the range, inclusive. RFC 3339, carrying a timezone offset
+     */
+    from: string;
+    /**
+     * End of the range, exclusive. RFC 3339, carrying a timezone offset
+     */
+    to: string;
+    /**
+     * Restricts the result to the specified model
+     * @maxLength 128
+     */
+    model_id?: string;
+    /**
+     * Restricts the result to the specified API key
+     */
+    api_key_id?: string;
+    /**
+     * Restricts the result to the specified status
+     */
+    status?: ListRequestsStatus;
+    /**
+     * Items returned in this page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    limit?: number;
+    /**
+     * The next_cursor returned by the previous page. Omit it for the first page.
+     * @minLength 1
+     * @maxLength 1024
+     */
+    cursor?: string;
+};
+export type ListRequestsStatus = (typeof ListRequestsStatus)[keyof typeof ListRequestsStatus];
+export declare const ListRequestsStatus: {
+    readonly in_flight: "in_flight";
+    readonly succeeded: "succeeded";
+    readonly refused: "refused";
+    readonly upstream_failed: "upstream_failed";
+    readonly client_aborted: "client_aborted";
+};
+export type ListUsageByApiKeyParams = {
+    /**
+     * Start of the range, inclusive. RFC 3339, carrying a timezone offset
+     */
+    from: string;
+    /**
+     * End of the range, exclusive. RFC 3339, carrying a timezone offset
+     */
+    to: string;
+    /**
+     * Restricts the result to the specified model
+     * @maxLength 128
+     */
+    model_id?: string;
+    /**
+     * Restricts the result to the specified API key
+     */
+    api_key_id?: string;
+    /**
+     * Restricts the result to the specified status
+     */
+    status?: ListUsageByApiKeyStatus;
+};
+export type ListUsageByApiKeyStatus = (typeof ListUsageByApiKeyStatus)[keyof typeof ListUsageByApiKeyStatus];
+export declare const ListUsageByApiKeyStatus: {
+    readonly in_flight: "in_flight";
+    readonly succeeded: "succeeded";
+    readonly refused: "refused";
+    readonly upstream_failed: "upstream_failed";
+    readonly client_aborted: "client_aborted";
+};
+export type ListUsageByModelParams = {
+    /**
+     * Start of the range, inclusive. RFC 3339, carrying a timezone offset
+     */
+    from: string;
+    /**
+     * End of the range, exclusive. RFC 3339, carrying a timezone offset
+     */
+    to: string;
+    /**
+     * Restricts the result to the specified model
+     * @maxLength 128
+     */
+    model_id?: string;
+    /**
+     * Restricts the result to the specified API key
+     */
+    api_key_id?: string;
+    /**
+     * Restricts the result to the specified status
+     */
+    status?: ListUsageByModelStatus;
+};
+export type ListUsageByModelStatus = (typeof ListUsageByModelStatus)[keyof typeof ListUsageByModelStatus];
+export declare const ListUsageByModelStatus: {
+    readonly in_flight: "in_flight";
+    readonly succeeded: "succeeded";
+    readonly refused: "refused";
+    readonly upstream_failed: "upstream_failed";
+    readonly client_aborted: "client_aborted";
+};
+export type GetUsageSummaryParams = {
+    /**
+     * Start of the range, inclusive. RFC 3339, carrying a timezone offset
+     */
+    from: string;
+    /**
+     * End of the range, exclusive. RFC 3339, carrying a timezone offset
+     */
+    to: string;
+    /**
+     * Restricts the result to the specified model
+     * @maxLength 128
+     */
+    model_id?: string;
+    /**
+     * Restricts the result to the specified API key
+     */
+    api_key_id?: string;
+    /**
+     * Restricts the result to the specified status
+     */
+    status?: GetUsageSummaryStatus;
+};
+export type GetUsageSummaryStatus = (typeof GetUsageSummaryStatus)[keyof typeof GetUsageSummaryStatus];
+export declare const GetUsageSummaryStatus: {
+    readonly in_flight: "in_flight";
+    readonly succeeded: "succeeded";
+    readonly refused: "refused";
+    readonly upstream_failed: "upstream_failed";
+    readonly client_aborted: "client_aborted";
+};
+export type GetUsageTimelineParams = {
+    /**
+     * Start of the range, inclusive. RFC 3339, carrying a timezone offset
+     */
+    from: string;
+    /**
+     * End of the range, exclusive. RFC 3339, carrying a timezone offset
+     */
+    to: string;
+    /**
+     * Restricts the result to the specified model
+     * @maxLength 128
+     */
+    model_id?: string;
+    /**
+     * Restricts the result to the specified API key
+     */
+    api_key_id?: string;
+    /**
+     * Restricts the result to the specified status
+     */
+    status?: GetUsageTimelineStatus;
+    /**
+     * The length of each bucket, written as a duration such as 1h or 24h. The number of buckets is limited to 100
+     * @maxLength 16
+     */
+    bucket?: string;
+};
+export type GetUsageTimelineStatus = (typeof GetUsageTimelineStatus)[keyof typeof GetUsageTimelineStatus];
+export declare const GetUsageTimelineStatus: {
+    readonly in_flight: "in_flight";
+    readonly succeeded: "succeeded";
+    readonly refused: "refused";
+    readonly upstream_failed: "upstream_failed";
+    readonly client_aborted: "client_aborted";
+};