@leaflow/sdk 0.108.0 → 0.110.0

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

@@ -0,0 +1,1616 @@
+/**
+ * Generated by orval 🍺
+ * Do not edit manually.
+ * Leaflow Billing API
+ * Products, prices, orders, subscriptions and account billing. Financial operations require an account access token and billing-account authorization. Public catalogue operations declare no security requirement.
+ * OpenAPI spec version: v1
+ */
+import type { AccountBalance, ActiveResourceList, AllowanceList, AutoRenewSet, BillingAccount, BillingAccountCreate, BillingAccountList, BillingAccountUpdate, Cancellation, CancellationCreate, CancellationList, CheckoutOrderRequest, CreditGrantList, CreditNote, CreditNoteItemList, CreditNoteList, CurrencyList, DiscountList, EntitlementList, Error, ErrorResponse, GetPlanHeaders, GetPriceHeaders, GetProductHeaders, Invoice, InvoiceItemList, InvoiceList, ListAccountDiscountsParams, ListActiveResourcesParams, ListAllowancesParams, ListBillingAccountsParams, ListCancellationsParams, ListCreditGrantsParams, ListCreditNoteItemsParams, ListCreditNotesParams, ListCurrenciesParams, ListEntitlementsParams, ListInvoiceItemsParams, ListInvoicesParams, ListOrderItemsParams, ListOrdersParams, ListPaymentMethodsParams, ListPaymentOptionsParams, ListPlansHeaders, ListPlansParams, ListPricesByPlanHeaders, ListPricesByPlanParams, ListPricesHeaders, ListPricesParams, ListProductsHeaders, ListProductsParams, ListProjectAssignmentsParams, ListRatesHeaders, ListRatesParams, ListRefundsParams, ListRenewalPricesParams, ListSpendParams, ListSubscriptionsParams, ListTopUpsParams, ListTransactionsParams, ListUsageChargesParams, MeteredUsage, NotModifiedResponse, Order, OrderCancel, OrderItemList, OrderList, PayInvoiceRequest, PayTogetherRequest, PaymentMethod, PaymentMethodList, PaymentMethodSetup, PaymentMethodSetupResult, PaymentOptionList, PaymentPreview, PaymentResult, Plan, PlanList, PreviewInvoicePaymentParams, Price, PriceList, Product, ProductID, ProductList, ProjectAssignment, ProjectAssignmentList, Quote, QuoteRequest, RateList, RefundList, RenewRequest, RenewalOrderRequest, RenewalPriceList, SetProjectAssignmentRequest, SpendRowList, Subscription, SubscriptionList, TopUp, TopUpCreate, TopUpList, TransactionList, UsageChargeList } from "./models.js";
+export type HTTPStatusCode1xx = 100 | 101 | 102 | 103;
+export type HTTPStatusCode2xx = 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207;
+export type HTTPStatusCode3xx = 300 | 301 | 302 | 303 | 304 | 305 | 307 | 308;
+export type HTTPStatusCode4xx = 400 | 401 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 419 | 420 | 421 | 422 | 423 | 424 | 426 | 428 | 429 | 431 | 451;
+export type HTTPStatusCode5xx = 500 | 501 | 502 | 503 | 504 | 505 | 507 | 511;
+export type HTTPStatusCodes = HTTPStatusCode1xx | HTTPStatusCode2xx | HTTPStatusCode3xx | HTTPStatusCode4xx | HTTPStatusCode5xx;
+export type listCurrenciesResponse200 = {
+    data: CurrencyList;
+    status: 200;
+};
+export type listCurrenciesResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listCurrenciesResponseSuccess = listCurrenciesResponse200 & {
+    headers: Headers;
+};
+export type listCurrenciesResponseError = listCurrenciesResponseDefault & {
+    headers: Headers;
+};
+export type listCurrenciesResponse = listCurrenciesResponseSuccess | listCurrenciesResponseError;
+export declare const getListCurrenciesUrl: (params?: ListCurrenciesParams) => string;
+/**
+ * The currencies a new billing account can be opened in. A retired currency is not listed,
+ * although accounts already opened in it keep working. Results are paginated.
+ * @summary List currencies accounts can be opened in
+ */
+export declare const listCurrencies: (params?: ListCurrenciesParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listCurrenciesResponse>;
+export type listBillingAccountsResponse200 = {
+    data: BillingAccountList;
+    status: 200;
+};
+export type listBillingAccountsResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listBillingAccountsResponseSuccess = listBillingAccountsResponse200 & {
+    headers: Headers;
+};
+export type listBillingAccountsResponseError = listBillingAccountsResponseDefault & {
+    headers: Headers;
+};
+export type listBillingAccountsResponse = listBillingAccountsResponseSuccess | listBillingAccountsResponseError;
+export declare const getListBillingAccountsUrl: (params?: ListBillingAccountsParams) => string;
+/**
+ * @summary List billing accounts
+ */
+export declare const listBillingAccounts: (params?: ListBillingAccountsParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listBillingAccountsResponse>;
+export type createBillingAccountResponse201 = {
+    data: BillingAccount;
+    status: 201;
+};
+export type createBillingAccountResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 201>;
+};
+export type createBillingAccountResponseSuccess = createBillingAccountResponse201 & {
+    headers: Headers;
+};
+export type createBillingAccountResponseError = createBillingAccountResponseDefault & {
+    headers: Headers;
+};
+export type createBillingAccountResponse = createBillingAccountResponseSuccess | createBillingAccountResponseError;
+export declare const getCreateBillingAccountUrl: () => string;
+/**
+ * The currency is chosen here and cannot be changed afterwards. Everything charged to the
+ * account — prices, orders, invoices, balance — is denominated in it.
+ *
+ * One person may hold several accounts, for example a personal one and one for a team.
+ * @summary Create billing account
+ */
+export declare const createBillingAccount: (billingAccountCreate: BillingAccountCreate, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<createBillingAccountResponse>;
+export type getBillingAccountResponse200 = {
+    data: BillingAccount;
+    status: 200;
+};
+export type getBillingAccountResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getBillingAccountResponseSuccess = getBillingAccountResponse200 & {
+    headers: Headers;
+};
+export type getBillingAccountResponseError = getBillingAccountResponseDefault & {
+    headers: Headers;
+};
+export type getBillingAccountResponse = getBillingAccountResponseSuccess | getBillingAccountResponseError;
+export declare const getGetBillingAccountUrl: (accountId: number) => string;
+/**
+ * @summary Get billing account
+ */
+export declare const getBillingAccount: (accountId: number, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getBillingAccountResponse>;
+export type updateBillingAccountResponse200 = {
+    data: BillingAccount;
+    status: 200;
+};
+export type updateBillingAccountResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type updateBillingAccountResponseSuccess = updateBillingAccountResponse200 & {
+    headers: Headers;
+};
+export type updateBillingAccountResponseError = updateBillingAccountResponseDefault & {
+    headers: Headers;
+};
+export type updateBillingAccountResponse = updateBillingAccountResponseSuccess | updateBillingAccountResponseError;
+export declare const getUpdateBillingAccountUrl: (accountId: number) => string;
+/**
+ * The legal name, address and tax identifier are copied onto each invoice when it is
+ * issued. Changing them here affects invoices issued afterwards, not those already sent.
+ *
+ * The currency cannot be changed.
+ * @summary Update billing account
+ */
+export declare const updateBillingAccount: (accountId: number, billingAccountUpdate: BillingAccountUpdate, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<updateBillingAccountResponse>;
+export type getAccountBalanceResponse200 = {
+    data: AccountBalance;
+    status: 200;
+};
+export type getAccountBalanceResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getAccountBalanceResponseSuccess = getAccountBalanceResponse200 & {
+    headers: Headers;
+};
+export type getAccountBalanceResponseError = getAccountBalanceResponseDefault & {
+    headers: Headers;
+};
+export type getAccountBalanceResponse = getAccountBalanceResponseSuccess | getAccountBalanceResponseError;
+export declare const getGetAccountBalanceUrl: (accountId: number) => string;
+/**
+ * @summary Get account balance
+ */
+export declare const getAccountBalance: (accountId: number, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getAccountBalanceResponse>;
+export type getAccountMeteredUsageResponse200 = {
+    data: MeteredUsage;
+    status: 200;
+};
+export type getAccountMeteredUsageResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getAccountMeteredUsageResponseSuccess = getAccountMeteredUsageResponse200 & {
+    headers: Headers;
+};
+export type getAccountMeteredUsageResponseError = getAccountMeteredUsageResponseDefault & {
+    headers: Headers;
+};
+export type getAccountMeteredUsageResponse = getAccountMeteredUsageResponseSuccess | getAccountMeteredUsageResponseError;
+export declare const getGetAccountMeteredUsageUrl: (accountId: number) => string;
+/**
+ * Whether the account has anything billed by usage, and what that usage has cost over the last
+ * seven days. Usage is paid from the balance, so this tells how much of the balance it is likely
+ * to need: the balance divided by `average_daily_amount` is roughly how many days it lasts.
+ * @summary Get account metered usage
+ */
+export declare const getAccountMeteredUsage: (accountId: number, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getAccountMeteredUsageResponse>;
+export type listPaymentOptionsResponse200 = {
+    data: PaymentOptionList;
+    status: 200;
+};
+export type listPaymentOptionsResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listPaymentOptionsResponseSuccess = listPaymentOptionsResponse200 & {
+    headers: Headers;
+};
+export type listPaymentOptionsResponseError = listPaymentOptionsResponseDefault & {
+    headers: Headers;
+};
+export type listPaymentOptionsResponse = listPaymentOptionsResponseSuccess | listPaymentOptionsResponseError;
+export declare const getListPaymentOptionsUrl: (accountId: number, params?: ListPaymentOptionsParams) => string;
+/**
+ * Lists the payment gateways and methods that currently accept payment in this account's currency, the
+ * preferred gateway first. Top-ups and invoice payments must name a gateway and method listed here;
+ * others are refused. An empty result means no online payment is available for this account.
+ * Results are paginated.
+ * @summary List payment options
+ */
+export declare const listPaymentOptions: (accountId: number, params?: ListPaymentOptionsParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listPaymentOptionsResponse>;
+export type listProjectAssignmentsResponse200 = {
+    data: ProjectAssignmentList;
+    status: 200;
+};
+export type listProjectAssignmentsResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listProjectAssignmentsResponseSuccess = listProjectAssignmentsResponse200 & {
+    headers: Headers;
+};
+export type listProjectAssignmentsResponseError = listProjectAssignmentsResponseDefault & {
+    headers: Headers;
+};
+export type listProjectAssignmentsResponse = listProjectAssignmentsResponseSuccess | listProjectAssignmentsResponseError;
+export declare const getListProjectAssignmentsUrl: (params?: ListProjectAssignmentsParams) => string;
+/**
+ * @summary List project assignments
+ */
+export declare const listProjectAssignments: (params?: ListProjectAssignmentsParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listProjectAssignmentsResponse>;
+export type getProjectAssignmentResponse200 = {
+    data: ProjectAssignment;
+    status: 200;
+};
+export type getProjectAssignmentResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getProjectAssignmentResponseSuccess = getProjectAssignmentResponse200 & {
+    headers: Headers;
+};
+export type getProjectAssignmentResponseError = getProjectAssignmentResponseDefault & {
+    headers: Headers;
+};
+export type getProjectAssignmentResponse = getProjectAssignmentResponseSuccess | getProjectAssignmentResponseError;
+export declare const getGetProjectAssignmentUrl: (projectId: string) => string;
+/**
+ * Returns the current assignment for the project identified by projectId. Returns 404 when
+ * no billing account is assigned; no resources can be created until one is assigned.
+ * @summary Get project assignment
+ */
+export declare const getProjectAssignment: (projectId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getProjectAssignmentResponse>;
+export type setProjectAssignmentResponse200 = {
+    data: ProjectAssignment;
+    status: 200;
+};
+export type setProjectAssignmentResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type setProjectAssignmentResponseSuccess = setProjectAssignmentResponse200 & {
+    headers: Headers;
+};
+export type setProjectAssignmentResponseError = setProjectAssignmentResponseDefault & {
+    headers: Headers;
+};
+export type setProjectAssignmentResponse = setProjectAssignmentResponseSuccess | setProjectAssignmentResponseError;
+export declare const getSetProjectAssignmentUrl: (projectId: string) => string;
+/**
+ * Charges already incurred remain with the billing account that was linked when they
+ * occurred, and are still invoiced to it. Metered resources are settled up to the moment of
+ * the change. Amounts owed by the previous billing account remain owed by it and do not
+ * prevent the change.
+ *
+ * Orders keep the billing account they were placed with and are fulfilled as placed. Periods
+ * already paid for are unaffected; renewals are charged to the new billing account.
+ *
+ * The request is refused once the project no longer accepts purchases because it is being
+ * deleted, and while a subscription or an order in progress in the project uses a currency
+ * other than that of the new billing account.
+ * @summary Set project assignment
+ */
+export declare const setProjectAssignment: (projectId: string, setProjectAssignmentRequest: SetProjectAssignmentRequest, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<setProjectAssignmentResponse>;
+export type unlinkProjectBillingAccountResponse204 = {
+    data: void;
+    status: 204;
+};
+export type unlinkProjectBillingAccountResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 204>;
+};
+export type unlinkProjectBillingAccountResponseSuccess = unlinkProjectBillingAccountResponse204 & {
+    headers: Headers;
+};
+export type unlinkProjectBillingAccountResponseError = unlinkProjectBillingAccountResponseDefault & {
+    headers: Headers;
+};
+export type unlinkProjectBillingAccountResponse = unlinkProjectBillingAccountResponseSuccess | unlinkProjectBillingAccountResponseError;
+export declare const getUnlinkProjectBillingAccountUrl: (projectId: string) => string;
+/**
+ * Ends the project's current assignment without deleting its assignment history.
+ *
+ * Permitted only when nothing in the project is still running or in progress: no metered
+ * resources, no subscriptions that have not ended, and no orders in progress, including
+ * changes scheduled for the end of a period. Orders are not modified by this request; wait
+ * for them to complete, and have the service that scheduled a change call it off.
+ *
+ * Charges already incurred remain with the billing account and are invoiced to it as usual.
+ * Amounts the billing account owes do not prevent unlinking.
+ *
+ * After this the project cannot make purchases until a billing account is linked again.
+ * @summary Unlink project billing account
+ */
+export declare const unlinkProjectBillingAccount: (projectId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<unlinkProjectBillingAccountResponse>;
+export type listTopUpsResponse200 = {
+    data: TopUpList;
+    status: 200;
+};
+export type listTopUpsResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listTopUpsResponseSuccess = listTopUpsResponse200 & {
+    headers: Headers;
+};
+export type listTopUpsResponseError = listTopUpsResponseDefault & {
+    headers: Headers;
+};
+export type listTopUpsResponse = listTopUpsResponseSuccess | listTopUpsResponseError;
+export declare const getListTopUpsUrl: (params?: ListTopUpsParams) => string;
+/**
+ * Lists only the authenticated user's top-ups. Includes pending, failed and canceled attempts; no invoice is
+ * created for a top-up. Items carry no `action`; read a pending top-up with get-top-up to continue its payment.
+ * @summary List top ups
+ */
+export declare const listTopUps: (params?: ListTopUpsParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listTopUpsResponse>;
+export type createTopUpResponse201 = {
+    data: TopUp;
+    status: 201;
+};
+export type createTopUpResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 201>;
+};
+export type createTopUpResponseSuccess = createTopUpResponse201 & {
+    headers: Headers;
+};
+export type createTopUpResponseError = createTopUpResponseDefault & {
+    headers: Headers;
+};
+export type createTopUpResponse = createTopUpResponseSuccess | createTopUpResponseError;
+export declare const getCreateTopUpUrl: () => string;
+/**
+ * Creates a top-up for an account owned by the authenticated user and returns its payment information.
+ * The balance increases only after the payment gateway confirms receipt. A top-up has no invoice.
+ * Keep the supplied ID to query the original attempt after a lost response; duplicate creation conflicts.
+ * @summary Create top up
+ */
+export declare const createTopUp: (topUpCreate: TopUpCreate, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<createTopUpResponse>;
+export type getTopUpResponse200 = {
+    data: TopUp;
+    status: 200;
+};
+export type getTopUpResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getTopUpResponseSuccess = getTopUpResponse200 & {
+    headers: Headers;
+};
+export type getTopUpResponseError = getTopUpResponseDefault & {
+    headers: Headers;
+};
+export type getTopUpResponse = getTopUpResponseSuccess | getTopUpResponseError;
+export declare const getGetTopUpUrl: (topUpId: string) => string;
+/**
+ * Reads a top-up owned by the authenticated user, including its outcome and the part of it not yet spent.
+ * It is not an invoice.
+ *
+ * While the top-up is pending, the answer includes the customer's next step as the payment gateway
+ * currently reports it, so that a payment interrupted by a closed page can be continued. When the gateway
+ * cannot be reached, the top-up is returned without `action`; read it again later.
+ * @summary Get top up
+ */
+export declare const getTopUp: (topUpId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getTopUpResponse>;
+export type cancelTopUpResponse200 = {
+    data: TopUp;
+    status: 200;
+};
+export type cancelTopUpResponse409 = {
+    data: Error;
+    status: 409;
+};
+export type cancelTopUpResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200 | 409>;
+};
+export type cancelTopUpResponseSuccess = cancelTopUpResponse200 & {
+    headers: Headers;
+};
+export type cancelTopUpResponseError = (cancelTopUpResponse409 | cancelTopUpResponseDefault) & {
+    headers: Headers;
+};
+export type cancelTopUpResponse = cancelTopUpResponseSuccess | cancelTopUpResponseError;
+export declare const getCancelTopUpUrl: (topUpId: string) => string;
+/**
+ * Withdraws a pending top-up owned by the authenticated user at the payment gateway. It becomes
+ * `canceled` with `cancellation_reason` `requested_by_customer`, and no money is collected for it. Canceling a
+ * top-up that is already canceled returns it unchanged.
+ *
+ * If the gateway has already collected the payment, nothing is withdrawn and the top-up is returned
+ * as `succeeded` with the balance increased. Check `status` in the answer rather than assuming the
+ * cancellation took effect.
+ *
+ * Fails with 409 and BILLING_TOPUP_NOT_CANCELABLE when the top-up has already succeeded or failed,
+ * with `status` naming that outcome, and while the gateway is processing the payment and can no
+ * longer withdraw it, with `status` set to `pending`; read the top-up again later in that case.
+ * @summary Cancel top up
+ */
+export declare const cancelTopUp: (topUpId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<cancelTopUpResponse>;
+export type listPaymentMethodsResponse200 = {
+    data: PaymentMethodList;
+    status: 200;
+};
+export type listPaymentMethodsResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listPaymentMethodsResponseSuccess = listPaymentMethodsResponse200 & {
+    headers: Headers;
+};
+export type listPaymentMethodsResponseError = listPaymentMethodsResponseDefault & {
+    headers: Headers;
+};
+export type listPaymentMethodsResponse = listPaymentMethodsResponseSuccess | listPaymentMethodsResponseError;
+export declare const getListPaymentMethodsUrl: (params?: ListPaymentMethodsParams) => string;
+/**
+ * @summary List payment methods
+ */
+export declare const listPaymentMethods: (params?: ListPaymentMethodsParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listPaymentMethodsResponse>;
+export type createPaymentMethodSetupResponse201 = {
+    data: PaymentMethodSetupResult;
+    status: 201;
+};
+export type createPaymentMethodSetupResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 201>;
+};
+export type createPaymentMethodSetupResponseSuccess = createPaymentMethodSetupResponse201 & {
+    headers: Headers;
+};
+export type createPaymentMethodSetupResponseError = createPaymentMethodSetupResponseDefault & {
+    headers: Headers;
+};
+export type createPaymentMethodSetupResponse = createPaymentMethodSetupResponseSuccess | createPaymentMethodSetupResponseError;
+export declare const getCreatePaymentMethodSetupUrl: () => string;
+/**
+ * Returns what is needed to hand the browser over to the payment gateway's own card
+ * form. Nothing is charged, and the method appears in the list once the gateway
+ * confirms it.
+ *
+ * Card numbers are never sent to or stored by this service.
+ * @summary Create payment method setup
+ */
+export declare const createPaymentMethodSetup: (paymentMethodSetup: PaymentMethodSetup, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<createPaymentMethodSetupResponse>;
+export type setDefaultPaymentMethodResponse200 = {
+    data: PaymentMethod;
+    status: 200;
+};
+export type setDefaultPaymentMethodResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type setDefaultPaymentMethodResponseSuccess = setDefaultPaymentMethodResponse200 & {
+    headers: Headers;
+};
+export type setDefaultPaymentMethodResponseError = setDefaultPaymentMethodResponseDefault & {
+    headers: Headers;
+};
+export type setDefaultPaymentMethodResponse = setDefaultPaymentMethodResponseSuccess | setDefaultPaymentMethodResponseError;
+export declare const getSetDefaultPaymentMethodUrl: (paymentMethodId: string) => string;
+/**
+ * @summary Set default payment method
+ */
+export declare const setDefaultPaymentMethod: (paymentMethodId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<setDefaultPaymentMethodResponse>;
+export type deletePaymentMethodResponse204 = {
+    data: void;
+    status: 204;
+};
+export type deletePaymentMethodResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 204>;
+};
+export type deletePaymentMethodResponseSuccess = deletePaymentMethodResponse204 & {
+    headers: Headers;
+};
+export type deletePaymentMethodResponseError = deletePaymentMethodResponseDefault & {
+    headers: Headers;
+};
+export type deletePaymentMethodResponse = deletePaymentMethodResponseSuccess | deletePaymentMethodResponseError;
+export declare const getDeletePaymentMethodUrl: (paymentMethodId: string) => string;
+/**
+ * Refused when it is the only method on an account that has resources billed by the hour,
+ * as there would be nothing left to charge when the balance runs out.
+ * @summary Delete payment method
+ */
+export declare const deletePaymentMethod: (paymentMethodId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<deletePaymentMethodResponse>;
+export type payInvoiceResponse200 = {
+    data: PaymentResult;
+    status: 200;
+};
+export type payInvoiceResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type payInvoiceResponseSuccess = payInvoiceResponse200 & {
+    headers: Headers;
+};
+export type payInvoiceResponseError = payInvoiceResponseDefault & {
+    headers: Headers;
+};
+export type payInvoiceResponse = payInvoiceResponseSuccess | payInvoiceResponseError;
+export declare const getPayInvoiceUrl: (invoiceId: string) => string;
+/**
+ * Applies eligible credit grants and available balance as requested, then collects the remainder
+ * through the selected payment gateway and method. With no gateway selection, insufficient
+ * account funds fail without starting an online payment. Card and non-card methods use this same
+ * operation. Promotion codes are confirmed by checkout, before collecting payment.
+ *
+ * Returns a payment action when customer interaction is required. requires_action and processing
+ * do not mean paid; the invoice is marked paid after payment is confirmed. An unresolved payment
+ * attempt is reused, and retries do not apply credit grants or balance twice.
+ *
+ * Calling this on an invoice that is already paid returns the existing payment result without
+ * another charge. A draft order invoice must first be confirmed through checkout. It and a void
+ * invoice are refused with `BILLING_INVOICE_NOT_PAYABLE`; the invoice of an order that has failed or was
+ * canceled, with `BILLING_ORDER_FAILED` or `BILLING_ORDER_CANCELED`; and that of an order whose
+ * payment deadline has passed, with `BILLING_ORDER_EXPIRED`.
+ * @summary Pay an invoice
+ */
+export declare const payInvoice: (invoiceId: string, payInvoiceRequest?: PayInvoiceRequest, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<payInvoiceResponse>;
+export type previewInvoicePaymentResponse200 = {
+    data: PaymentPreview;
+    status: 200;
+};
+export type previewInvoicePaymentResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type previewInvoicePaymentResponseSuccess = previewInvoicePaymentResponse200 & {
+    headers: Headers;
+};
+export type previewInvoicePaymentResponseError = previewInvoicePaymentResponseDefault & {
+    headers: Headers;
+};
+export type previewInvoicePaymentResponse = previewInvoicePaymentResponseSuccess | previewInvoicePaymentResponseError;
+export declare const getPreviewInvoicePaymentUrl: (invoiceId: string, params?: PreviewInvoicePaymentParams) => string;
+/**
+ * What paying this invoice now would take from credit grants, from the balance and, for the rest,
+ * from a payment gateway. It is computed as paying computes it, so paying with the same options
+ * straight afterwards takes exactly these amounts unless the account's funds change in between.
+ * Nothing is charged, reserved or created.
+ *
+ * Refused with the same errors as paying, except that insufficient funds are not an error here:
+ * they show as a `gateway_amount` above zero.
+ * @summary Preview invoice payment
+ */
+export declare const previewInvoicePayment: (invoiceId: string, params?: PreviewInvoicePaymentParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<previewInvoicePaymentResponse>;
+export type payTogetherResponse200 = {
+    data: PaymentResult;
+    status: 200;
+};
+export type payTogetherResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type payTogetherResponseSuccess = payTogetherResponse200 & {
+    headers: Headers;
+};
+export type payTogetherResponseError = payTogetherResponseDefault & {
+    headers: Headers;
+};
+export type payTogetherResponse = payTogetherResponseSuccess | payTogetherResponseError;
+export declare const getPayTogetherUrl: () => string;
+/**
+ * Pays outstanding invoices, including the invoices of the listed orders, from the account's
+ * eligible credit grants and then its balance. No payment gateway is used; an invoice to be
+ * paid online is paid on its own.
+ *
+ * Either every invoice is paid or none is. When the credit grants and balance cannot cover
+ * them all, the request fails with `BILLING_INSUFFICIENT_FUNDS` and nothing is charged.
+ * Invoices that are already paid are not charged again. An invoice with an online payment
+ * still in progress is refused with `BILLING_PAYMENT_PENDING`, a draft order invoice or void invoice with
+ * `BILLING_INVOICE_NOT_PAYABLE`, an order that has failed or was canceled with
+ * `BILLING_ORDER_FAILED` or `BILLING_ORDER_CANCELED`, and an order whose payment deadline has
+ * passed with `BILLING_ORDER_EXPIRED`.
+ * @summary Pay together
+ */
+export declare const payTogether: (payTogetherRequest: PayTogetherRequest, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<payTogetherResponse>;
+export type previewPayTogetherResponse200 = {
+    data: PaymentPreview;
+    status: 200;
+};
+export type previewPayTogetherResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type previewPayTogetherResponseSuccess = previewPayTogetherResponse200 & {
+    headers: Headers;
+};
+export type previewPayTogetherResponseError = previewPayTogetherResponseDefault & {
+    headers: Headers;
+};
+export type previewPayTogetherResponse = previewPayTogetherResponseSuccess | previewPayTogetherResponseError;
+export declare const getPreviewPayTogetherUrl: () => string;
+/**
+ * What paying these invoices together now would take from credit grants and from the balance,
+ * invoice by invoice in the order they would be paid. It is computed as paying together computes
+ * it. Nothing is charged, reserved or created.
+ *
+ * Refused with the same errors as paying together, except that insufficient funds are not an
+ * error here: they show as a `gateway_amount` above zero, and paying together would then be
+ * refused with `BILLING_INSUFFICIENT_FUNDS`.
+ * @summary Preview paying together
+ */
+export declare const previewPayTogether: (payTogetherRequest: PayTogetherRequest, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<previewPayTogetherResponse>;
+export type listInvoicesResponse200 = {
+    data: InvoiceList;
+    status: 200;
+};
+export type listInvoicesResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listInvoicesResponseSuccess = listInvoicesResponse200 & {
+    headers: Headers;
+};
+export type listInvoicesResponseError = listInvoicesResponseDefault & {
+    headers: Headers;
+};
+export type listInvoicesResponse = listInvoicesResponseSuccess | listInvoicesResponseError;
+export declare const getListInvoicesUrl: (params?: ListInvoicesParams) => string;
+/**
+ * @summary List invoices
+ */
+export declare const listInvoices: (params?: ListInvoicesParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listInvoicesResponse>;
+export type getInvoiceResponse200 = {
+    data: Invoice;
+    status: 200;
+};
+export type getInvoiceResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getInvoiceResponseSuccess = getInvoiceResponse200 & {
+    headers: Headers;
+};
+export type getInvoiceResponseError = getInvoiceResponseDefault & {
+    headers: Headers;
+};
+export type getInvoiceResponse = getInvoiceResponseSuccess | getInvoiceResponseError;
+export declare const getGetInvoiceUrl: (invoiceId: string) => string;
+/**
+ * @summary Get invoice
+ */
+export declare const getInvoice: (invoiceId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getInvoiceResponse>;
+export type listInvoiceItemsResponse200 = {
+    data: InvoiceItemList;
+    status: 200;
+};
+export type listInvoiceItemsResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listInvoiceItemsResponseSuccess = listInvoiceItemsResponse200 & {
+    headers: Headers;
+};
+export type listInvoiceItemsResponseError = listInvoiceItemsResponseDefault & {
+    headers: Headers;
+};
+export type listInvoiceItemsResponse = listInvoiceItemsResponseSuccess | listInvoiceItemsResponseError;
+export declare const getListInvoiceItemsUrl: (invoiceId: string, params?: ListInvoiceItemsParams) => string;
+/**
+ * @summary List invoice items
+ */
+export declare const listInvoiceItems: (invoiceId: string, params?: ListInvoiceItemsParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listInvoiceItemsResponse>;
+export type listTransactionsResponse200 = {
+    data: TransactionList;
+    status: 200;
+};
+export type listTransactionsResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listTransactionsResponseSuccess = listTransactionsResponse200 & {
+    headers: Headers;
+};
+export type listTransactionsResponseError = listTransactionsResponseDefault & {
+    headers: Headers;
+};
+export type listTransactionsResponse = listTransactionsResponseSuccess | listTransactionsResponseError;
+export declare const getListTransactionsUrl: (params?: ListTransactionsParams) => string;
+/**
+ * @summary List transactions
+ */
+export declare const listTransactions: (params?: ListTransactionsParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listTransactionsResponse>;
+export type listAccountDiscountsResponse200 = {
+    data: DiscountList;
+    status: 200;
+};
+export type listAccountDiscountsResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listAccountDiscountsResponseSuccess = listAccountDiscountsResponse200 & {
+    headers: Headers;
+};
+export type listAccountDiscountsResponseError = listAccountDiscountsResponseDefault & {
+    headers: Headers;
+};
+export type listAccountDiscountsResponse = listAccountDiscountsResponseSuccess | listAccountDiscountsResponseError;
+export declare const getListAccountDiscountsUrl: (params?: ListAccountDiscountsParams) => string;
+/**
+ * Coupons placed on the account directly, which apply at checkout without a code being
+ * entered. A coupon reached through a code is not listed here.
+ * @summary List the coupons held on this account
+ */
+export declare const listAccountDiscounts: (params?: ListAccountDiscountsParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listAccountDiscountsResponse>;
+export type listCreditGrantsResponse200 = {
+    data: CreditGrantList;
+    status: 200;
+};
+export type listCreditGrantsResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listCreditGrantsResponseSuccess = listCreditGrantsResponse200 & {
+    headers: Headers;
+};
+export type listCreditGrantsResponseError = listCreditGrantsResponseDefault & {
+    headers: Headers;
+};
+export type listCreditGrantsResponse = listCreditGrantsResponseSuccess | listCreditGrantsResponseError;
+export declare const getListCreditGrantsUrl: (params?: ListCreditGrantsParams) => string;
+/**
+ * Each grant shows what remains and what it may be used for. Credit is spent before the balance
+ * and cannot be withdrawn.
+ * @summary List credit grants
+ */
+export declare const listCreditGrants: (params?: ListCreditGrantsParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listCreditGrantsResponse>;
+export type listCreditNotesResponse200 = {
+    data: CreditNoteList;
+    status: 200;
+};
+export type listCreditNotesResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listCreditNotesResponseSuccess = listCreditNotesResponse200 & {
+    headers: Headers;
+};
+export type listCreditNotesResponseError = listCreditNotesResponseDefault & {
+    headers: Headers;
+};
+export type listCreditNotesResponse = listCreditNotesResponseSuccess | listCreditNotesResponseError;
+export declare const getListCreditNotesUrl: (params?: ListCreditNotesParams) => string;
+/**
+ * Newest issued_at first, then ID. Requires authorization for the invoice's billing account. Filters narrow authorized results and apply before counting and paging.
+ * @summary List credit notes
+ */
+export declare const listCreditNotes: (params?: ListCreditNotesParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listCreditNotesResponse>;
+export type getCreditNoteResponse200 = {
+    data: CreditNote;
+    status: 200;
+};
+export type getCreditNoteResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getCreditNoteResponseSuccess = getCreditNoteResponse200 & {
+    headers: Headers;
+};
+export type getCreditNoteResponseError = getCreditNoteResponseDefault & {
+    headers: Headers;
+};
+export type getCreditNoteResponse = getCreditNoteResponseSuccess | getCreditNoteResponseError;
+export declare const getGetCreditNoteUrl: (creditNoteId: string) => string;
+/**
+ * Requires authorization for the invoice's billing account.
+ * @summary Get credit note
+ */
+export declare const getCreditNote: (creditNoteId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getCreditNoteResponse>;
+export type listCreditNoteItemsResponse200 = {
+    data: CreditNoteItemList;
+    status: 200;
+};
+export type listCreditNoteItemsResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listCreditNoteItemsResponseSuccess = listCreditNoteItemsResponse200 & {
+    headers: Headers;
+};
+export type listCreditNoteItemsResponseError = listCreditNoteItemsResponseDefault & {
+    headers: Headers;
+};
+export type listCreditNoteItemsResponse = listCreditNoteItemsResponseSuccess | listCreditNoteItemsResponseError;
+export declare const getListCreditNoteItemsUrl: (creditNoteId: string, params?: ListCreditNoteItemsParams) => string;
+/**
+ * The original invoice lines reduced by this note. Requires authorization for their invoice's billing account.
+ * @summary List credit note items
+ */
+export declare const listCreditNoteItems: (creditNoteId: string, params?: ListCreditNoteItemsParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listCreditNoteItemsResponse>;
+export type listRefundsResponse200 = {
+    data: RefundList;
+    status: 200;
+};
+export type listRefundsResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listRefundsResponseSuccess = listRefundsResponse200 & {
+    headers: Headers;
+};
+export type listRefundsResponseError = listRefundsResponseDefault & {
+    headers: Headers;
+};
+export type listRefundsResponse = listRefundsResponseSuccess | listRefundsResponseError;
+export declare const getListRefundsUrl: (params?: ListRefundsParams) => string;
+/**
+ * Newest first.
+ * @summary List refunds
+ */
+export declare const listRefunds: (params?: ListRefundsParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listRefundsResponse>;
+export type listUsageChargesResponse200 = {
+    data: UsageChargeList;
+    status: 200;
+};
+export type listUsageChargesResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listUsageChargesResponseSuccess = listUsageChargesResponse200 & {
+    headers: Headers;
+};
+export type listUsageChargesResponseError = listUsageChargesResponseDefault & {
+    headers: Headers;
+};
+export type listUsageChargesResponse = listUsageChargesResponseSuccess | listUsageChargesResponseError;
+export declare const getListUsageChargesUrl: (params?: ListUsageChargesParams) => string;
+/**
+ * Each charge is added to the month's usage invoice as it is priced, summed into one line per
+ * subscription, project, resource, meter and rate. Filter by `invoice_item_id` to see the
+ * charges behind a line. Charges still waiting to be priced are included too.
+ *
+ * Only charges recorded against your billing accounts are included, before filtering, counting and pagination. Reassigning a project does not move previously recorded charges to its new account.
+ * @summary List usage charges
+ */
+export declare const listUsageCharges: (params?: ListUsageChargesParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listUsageChargesResponse>;
+export type listSubscriptionsResponse200 = {
+    data: SubscriptionList;
+    status: 200;
+};
+export type listSubscriptionsResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listSubscriptionsResponseSuccess = listSubscriptionsResponse200 & {
+    headers: Headers;
+};
+export type listSubscriptionsResponseError = listSubscriptionsResponseDefault & {
+    headers: Headers;
+};
+export type listSubscriptionsResponse = listSubscriptionsResponseSuccess | listSubscriptionsResponseError;
+export declare const getListSubscriptionsUrl: (params?: ListSubscriptionsParams) => string;
+/**
+ * @summary List subscriptions
+ */
+export declare const listSubscriptions: (params?: ListSubscriptionsParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listSubscriptionsResponse>;
+export type getSubscriptionResponse200 = {
+    data: Subscription;
+    status: 200;
+};
+export type getSubscriptionResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getSubscriptionResponseSuccess = getSubscriptionResponse200 & {
+    headers: Headers;
+};
+export type getSubscriptionResponseError = getSubscriptionResponseDefault & {
+    headers: Headers;
+};
+export type getSubscriptionResponse = getSubscriptionResponseSuccess | getSubscriptionResponseError;
+export declare const getGetSubscriptionUrl: (subscriptionId: string) => string;
+/**
+ * @summary Get subscription
+ */
+export declare const getSubscription: (subscriptionId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getSubscriptionResponse>;
+export type createQuoteResponse200 = {
+    data: Quote;
+    status: 200;
+};
+export type createQuoteResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type createQuoteResponseSuccess = createQuoteResponse200 & {
+    headers: Headers;
+};
+export type createQuoteResponseError = createQuoteResponseDefault & {
+    headers: Headers;
+};
+export type createQuoteResponse = createQuoteResponseSuccess | createQuoteResponseError;
+export declare const getCreateQuoteUrl: () => string;
+/**
+ * Calculates exactly one target for a billing account you own: proposed items, existing order checkout, renewals, cancellation or order refund. Returns all requested calculations or a structured error. No quote is saved and no resource, payment, reservation or redemption is created.
+ *
+ * Existing orders use their recorded purchase account and terms. Renewals and cancellations use the account currently paying for each subscription. Every target must belong to the requested account. A project association or project token does not authorize a quote.
+ *
+ * Use an existing order quote's total as expected_amount at checkout. A confirmed order returns its recorded amounts; a different promotion code is refused. Requested future usage estimates are not collectible checkout amounts. An unknown delivery outcome is not proof of refund eligibility.
+ * @summary Create a quote
+ */
+export declare const createQuote: (quoteRequest: QuoteRequest, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<createQuoteResponse>;
+export type listCancellationsResponse200 = {
+    data: CancellationList;
+    status: 200;
+};
+export type listCancellationsResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listCancellationsResponseSuccess = listCancellationsResponse200 & {
+    headers: Headers;
+};
+export type listCancellationsResponseError = listCancellationsResponseDefault & {
+    headers: Headers;
+};
+export type listCancellationsResponse = listCancellationsResponseSuccess | listCancellationsResponseError;
+export declare const getListCancellationsUrl: (params?: ListCancellationsParams) => string;
+/**
+ * Newest first. Filter by `subscription_id` and `status=open` to find the cancellation now under way for a subscription.
+ * @summary List cancellations
+ */
+export declare const listCancellations: (params?: ListCancellationsParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listCancellationsResponse>;
+export type createCancellationResponse200 = {
+    data: Cancellation;
+    status: 200;
+};
+export type createCancellationResponse201 = {
+    data: Cancellation;
+    status: 201;
+};
+export type createCancellationResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200 | 201>;
+};
+export type createCancellationResponseSuccess = (createCancellationResponse200 | createCancellationResponse201) & {
+    headers: Headers;
+};
+export type createCancellationResponseError = createCancellationResponseDefault & {
+    headers: Headers;
+};
+export type createCancellationResponse = createCancellationResponseSuccess | createCancellationResponseError;
+export declare const getCreateCancellationUrl: () => string;
+/**
+ * Ends a set of subscriptions of one service together, at one time. Deleting a resource that a
+ * subscription pays for is an `immediate` cancellation of every subscription released with it,
+ * such as a server with the disks deleted along with it, or an address with its bandwidth.
+ *
+ * The service that provides the resources releases them: at once for `immediate`, or at
+ * `scheduled_at`, the end of the paid term, for `period_end`. When release is confirmed, the
+ * unused value is returned the way it was paid, under the refund terms agreed when each
+ * subscription was bought. For `immediate` the refund is computed as of `proration_date`, so the
+ * amount confirmed here is the amount returned: prepaid service used while the resources are
+ * being released is not deducted from it. Usage of a postpaid subscription is charged until its
+ * resources are released, as usual.
+ *
+ * `mode` must be allowed for every subscription. Postpaid and one-time subscriptions end only
+ * `immediate`. A prepaid subscription ends `period_end` while its paid term lasts, and
+ * `immediate` unless its termination terms allow only the end of the paid term and that term has
+ * not ended yet. For `period_end` the paid terms of all the subscriptions must end at the same
+ * time.
+ *
+ * Refused with:
+ * - 400 `BILLING_CANCELLATION_INVALID` when `subscription_ids` or `proration_date` is not
+ *   acceptable (`meta.field`), or the subscriptions do not all belong to one service, project,
+ *   account and currency;
+ * - 409 `BILLING_CANCELLATION_CONFLICT` when a subscription has not started or has ended;
+ * - 422 `BILLING_CANCELLATION_MODE_FIXED` when `mode` is not allowed for a subscription, and
+ *   `BILLING_CANCELLATION_TERMS_UNSET` when a prepaid subscription has no termination terms;
+ *   both carry `meta.subscription_id`;
+ * - 409 `BILLING_CANCELLATION_SCHEDULES_DIFFER` when, for `period_end`, the paid terms end at
+ *   different times;
+ * - 409 `BILLING_SUBSCRIPTION_OPERATION_PENDING` when a subscription is already being canceled
+ *   (`meta.cancellation_id`) or reclaimed (`meta.action_id`);
+ * - 409 `BILLING_ORDER_PAYMENT_IN_FLIGHT` while an online payment for a renewal of one of them
+ *   is in progress;
+ * - 409 `BILLING_CANCELLATION_REFUND_CHANGED` when the refund is no longer
+ *   `expected_refundable_amount`; quote again.
+ *
+ * Sending the same request again, for the same subscriptions, mode and amount while that
+ * cancellation is still open, returns it with 200 rather than creating another. Renewal orders
+ * still waiting for payment are canceled along with it, and automatic renewal is turned off for
+ * every subscription in the set, for `period_end` as well as `immediate`.
+ * @summary Cancel subscriptions
+ */
+export declare const createCancellation: (cancellationCreate: CancellationCreate, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<createCancellationResponse>;
+export type getCancellationResponse200 = {
+    data: Cancellation;
+    status: 200;
+};
+export type getCancellationResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getCancellationResponseSuccess = getCancellationResponse200 & {
+    headers: Headers;
+};
+export type getCancellationResponseError = getCancellationResponseDefault & {
+    headers: Headers;
+};
+export type getCancellationResponse = getCancellationResponseSuccess | getCancellationResponseError;
+export declare const getGetCancellationUrl: (cancellationId: string) => string;
+/**
+ * @summary Get a cancellation
+ */
+export declare const getCancellation: (cancellationId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getCancellationResponse>;
+export type withdrawCancellationResponse200 = {
+    data: Cancellation;
+    status: 200;
+};
+export type withdrawCancellationResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type withdrawCancellationResponseSuccess = withdrawCancellationResponse200 & {
+    headers: Headers;
+};
+export type withdrawCancellationResponseError = withdrawCancellationResponseDefault & {
+    headers: Headers;
+};
+export type withdrawCancellationResponse = withdrawCancellationResponseSuccess | withdrawCancellationResponseError;
+export declare const getWithdrawCancellationUrl: (cancellationId: string) => string;
+/**
+ * Withdraws the whole cancellation while none of its resources has begun to be released; the
+ * subscriptions continue as before, except that automatic renewal, turned off when the
+ * cancellation was created, stays off until it is turned on again. After that it is refused with
+ * 409 `BILLING_CANCELLATION_CONFLICT`. Withdrawing one that is already withdrawn returns it
+ * unchanged.
+ * @summary Withdraw a cancellation
+ */
+export declare const withdrawCancellation: (cancellationId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<withdrawCancellationResponse>;
+export type listRenewalPricesResponse200 = {
+    data: RenewalPriceList;
+    status: 200;
+};
+export type listRenewalPricesResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listRenewalPricesResponseSuccess = listRenewalPricesResponse200 & {
+    headers: Headers;
+};
+export type listRenewalPricesResponseError = listRenewalPricesResponseDefault & {
+    headers: Headers;
+};
+export type listRenewalPricesResponse = listRenewalPricesResponseSuccess | listRenewalPricesResponseError;
+export declare const getListRenewalPricesUrl: (subscriptionId: string, params?: ListRenewalPricesParams) => string;
+/**
+ * Lists the current renewal agreement and available intervals. The current option preserves recurring_amount; other options use current prices. Amounts cover the whole subscription quantity and exclude tax.
+ * @summary List the terms this item can be renewed for
+ */
+export declare const listRenewalPrices: (subscriptionId: string, params?: ListRenewalPricesParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listRenewalPricesResponse>;
+export type renewSubscriptionResponse200 = {
+    data: PaymentResult;
+    status: 200;
+};
+export type renewSubscriptionResponse409 = {
+    data: Error;
+    status: 409;
+};
+export type renewSubscriptionResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200 | 409>;
+};
+export type renewSubscriptionResponseSuccess = renewSubscriptionResponse200 & {
+    headers: Headers;
+};
+export type renewSubscriptionResponseError = (renewSubscriptionResponse409 | renewSubscriptionResponseDefault) & {
+    headers: Headers;
+};
+export type renewSubscriptionResponse = renewSubscriptionResponseSuccess | renewSubscriptionResponseError;
+export declare const getRenewSubscriptionUrl: (subscriptionId: string) => string;
+/**
+ * Purchases prepaid periods from paid_until using the agreed recurring amount, and pays for them at
+ * once. A changed interval selects a current price and freezes new terms on the order, applied
+ * only after fulfillment. Existing paid periods keep their value.
+ *
+ * Without `payment_method_id`, the renewal is paid from credit grants and the balance as
+ * `use_credits` and `use_balance` allow; when they cannot pay it all, the renewal is refused with
+ * `BILLING_INSUFFICIENT_FUNDS` and no order is left. To pay another way, create a renewal order
+ * and pay its invoice instead.
+ *
+ * Save order_id before submitting and query the order after an unknown outcome; duplicate
+ * creation conflicts.
+ * @summary Renew subscription
+ */
+export declare const renewSubscription: (subscriptionId: string, renewRequest: RenewRequest, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<renewSubscriptionResponse>;
+export type createRenewalOrderResponse200 = {
+    data: Order;
+    status: 200;
+};
+export type createRenewalOrderResponse409 = {
+    data: Error;
+    status: 409;
+};
+export type createRenewalOrderResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200 | 409>;
+};
+export type createRenewalOrderResponseSuccess = createRenewalOrderResponse200 & {
+    headers: Headers;
+};
+export type createRenewalOrderResponseError = (createRenewalOrderResponse409 | createRenewalOrderResponseDefault) & {
+    headers: Headers;
+};
+export type createRenewalOrderResponse = createRenewalOrderResponseSuccess | createRenewalOrderResponseError;
+export declare const getCreateRenewalOrderUrl: (subscriptionId: string) => string;
+/**
+ * Places a renewal order with a draft invoice, without applying a new discount or charging anything.
+ * Quote and confirm its checkout before collecting payment to renew. Existing subscription
+ * discount commitments are retained. The periods and price are chosen as for renewing. The order
+ * can be paid until the current paid period ends, and never after the end of the first period it renews; unpaid by
+ * then, it is canceled. While auto-renew is on, the renewal due at the end of the period pays
+ * this order instead of placing another, confirming checkout with an applicable account discount
+ * first if it has not already been confirmed.
+ *
+ * Save `order_id` before submitting and read the order after an unknown outcome; creating it a
+ * second time conflicts.
+ * @summary Create renewal order
+ */
+export declare const createRenewalOrder: (subscriptionId: string, renewalOrderRequest: RenewalOrderRequest, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<createRenewalOrderResponse>;
+export type setAutoRenewResponse200 = {
+    data: Subscription;
+    status: 200;
+};
+export type setAutoRenewResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type setAutoRenewResponseSuccess = setAutoRenewResponse200 & {
+    headers: Headers;
+};
+export type setAutoRenewResponseError = setAutoRenewResponseDefault & {
+    headers: Headers;
+};
+export type setAutoRenewResponse = setAutoRenewResponseSuccess | setAutoRenewResponseError;
+export declare const getSetAutoRenewUrl: (subscriptionId: string) => string;
+/**
+ * Controls automatic prepaid renewal. Disabling it does not shorten paid_until and still permits
+ * manual renewal. Postpaid subscriptions do not renew and keep this false.
+ *
+ * While the subscription has an open cancellation, turning it on or off is refused with 409
+ * `BILLING_SUBSCRIPTION_OPERATION_PENDING` and `meta.cancellation_id`: creating the cancellation
+ * turned it off, and withdrawing the cancellation does not turn it back on.
+ * @summary Set auto renew
+ */
+export declare const setAutoRenew: (subscriptionId: string, autoRenewSet: AutoRenewSet, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<setAutoRenewResponse>;
+export type listAllowancesResponse200 = {
+    data: AllowanceList;
+    status: 200;
+};
+export type listAllowancesResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listAllowancesResponseSuccess = listAllowancesResponse200 & {
+    headers: Headers;
+};
+export type listAllowancesResponseError = listAllowancesResponseDefault & {
+    headers: Headers;
+};
+export type listAllowancesResponse = listAllowancesResponseSuccess | listAllowancesResponseError;
+export declare const getListAllowancesUrl: (params?: ListAllowancesParams) => string;
+/**
+ * Lists remaining usage quantities, such as bytes, seconds or tokens. Applicable allowances are
+ * consumed before usage is charged. Lower priority values are consumed first, followed by earlier
+ * expiry and earlier issuance.
+ *
+ * Unused quantity expires without a refund or carry-over. Promotional allowances apply to usage paid
+ * by their holding account. Included allowances apply only to the associated subscription, including
+ * after its project moves to another billing account.
+ * @summary List allowances
+ */
+export declare const listAllowances: (params?: ListAllowancesParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listAllowancesResponse>;
+export type listOrdersResponse200 = {
+    data: OrderList;
+    status: 200;
+};
+export type listOrdersResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listOrdersResponseSuccess = listOrdersResponse200 & {
+    headers: Headers;
+};
+export type listOrdersResponseError = listOrdersResponseDefault & {
+    headers: Headers;
+};
+export type listOrdersResponse = listOrdersResponseSuccess | listOrdersResponseError;
+export declare const getListOrdersUrl: (params?: ListOrdersParams) => string;
+/**
+ * Lists acceptance status and associated invoice amounts. pending_checkout awaits confirmation;
+ * pending has confirmed checkout and may be unpaid or paid. active means accepted, not delivered.
+ * pending_checkout and pending orders can expire at expires_at.
+ * @summary List orders
+ */
+export declare const listOrders: (params?: ListOrdersParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listOrdersResponse>;
+export type getOrderResponse200 = {
+    data: Order;
+    status: 200;
+};
+export type getOrderResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getOrderResponseSuccess = getOrderResponse200 & {
+    headers: Headers;
+};
+export type getOrderResponseError = getOrderResponseDefault & {
+    headers: Headers;
+};
+export type getOrderResponse = getOrderResponseSuccess | getOrderResponseError;
+export declare const getGetOrderUrl: (orderId: string) => string;
+/**
+ * @summary Get order
+ */
+export declare const getOrder: (orderId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getOrderResponse>;
+export type checkoutOrderResponse200 = {
+    data: Order;
+    status: 200;
+};
+export type checkoutOrderResponse409 = {
+    data: Error;
+    status: 409;
+};
+export type checkoutOrderResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200 | 409>;
+};
+export type checkoutOrderResponseSuccess = checkoutOrderResponse200 & {
+    headers: Headers;
+};
+export type checkoutOrderResponseError = (checkoutOrderResponse409 | checkoutOrderResponseDefault) & {
+    headers: Headers;
+};
+export type checkoutOrderResponse = checkoutOrderResponseSuccess | checkoutOrderResponseError;
+export declare const getCheckoutOrderUrl: (orderId: string) => string;
+/**
+ * Confirms the purchase's final amount and discount. Supply the same promotion_code used for the
+ * preview, or omit it to select an applicable account discount. At most one new coupon is applied
+ * to an order; existing subscription discount commitments are not stacked with a new coupon on
+ * the same line. Promotion codes are evaluated against the order, not client-supplied line amounts.
+ *
+ * Rechecks eligibility and redemption availability. A different total fails with
+ * BILLING_AMOUNT_CHANGED. An invalid or inapplicable code fails rather than collecting full price.
+ * A failed confirmation leaves the invoice draft and reserves no discount redemption.
+ *
+ * A successful confirmation records the discount, including any recurring discount terms,
+ * reserves its redemption, moves pending_checkout to pending and finalizes the invoice when one
+ * is required. The reservation counts toward the code's limits and is consumed when the invoice
+ * is paid, or at confirmation when nothing is due. Use pay-invoice to collect
+ * its outstanding amount from account funds or a payment gateway. No payment attempt or checkout
+ * session is created by this operation. An order whose total is zero completes checkout at
+ * placement in either mode and does not need this operation; an order with an amount due, even
+ * when credits would cover it, still does. Checkout alone does not confirm resource delivery.
+ *
+ * Retrying with the same code and expected amount returns the existing order without another
+ * redemption. Omitting the code on a confirmed checkout retains its recorded discount. Changing
+ * that code is refused with BILLING_ORDER_CHECKOUT_CONFLICT. Payment retries reuse the confirmed
+ * terms. Cancellation, expiry or complete fulfillment failure releases the reservation or returns
+ * the consumed redemption; a refund alone does not.
+ *
+ * The order must belong to one of your billing accounts. A canceled, failed or expired order
+ * cannot be checked out. A period-end change cannot be checked out before its renewal invoice is
+ * available. Orders retain their billing account and currency after a project is linked elsewhere;
+ * discounts from another account cannot be used for them.
+ * @summary Confirm order checkout
+ */
+export declare const checkoutOrder: (orderId: string, checkoutOrderRequest: CheckoutOrderRequest, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<checkoutOrderResponse>;
+export type cancelOrderResponse200 = {
+    data: Order;
+    status: 200;
+};
+export type cancelOrderResponse409 = {
+    data: Error;
+    status: 409;
+};
+export type cancelOrderResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200 | 409>;
+};
+export type cancelOrderResponseSuccess = cancelOrderResponse200 & {
+    headers: Headers;
+};
+export type cancelOrderResponseError = (cancelOrderResponse409 | cancelOrderResponseDefault) & {
+    headers: Headers;
+};
+export type cancelOrderResponse = cancelOrderResponseSuccess | cancelOrderResponseError;
+export declare const getCancelOrderUrl: (orderId: string) => string;
+/**
+ * Cancels the selected, still-undelivered items of an unaccepted order without recording a
+ * delivery failure. Omit order_item_ids to select every still-pending item, or name one or
+ * more items. Successful items remain delivered and are not refunded. Whole-order and partial
+ * cancellation both require confirmed non-delivery and necessary cleanup. The order keeps
+ * its existing pending phase while any item is still pending; its final outcome follows all
+ * item outcomes. Previously failed items keep their failure outcome.
+ *
+ * Payment may be absent, partial or complete. Confirmed checkout keeps the selected items'
+ * agreed amounts and discounts; credit notes reduce issued invoices, and collected amounts
+ * are returned to their original payment sources. When checkout has not been confirmed, the
+ * remaining items are quoted again. External payment-method refunds can finish asynchronously.
+ * The order and financial history are retained; the same cancellation does not refund twice.
+ *
+ * Once the order is accepted, its owning service coordinates cancellation and confirms
+ * non-delivery and cleanup through the cancellation RPC. Delivered items are ended through
+ * subscription cancellation. Unknown delivery or payment outcomes are not refund evidence;
+ * in-flight or unknown payments must be reconciled first. Scheduled changes continue to be
+ * canceled through the owning service. Refund quotations use CreateQuote.refund.
+ * @summary Cancel order
+ */
+export declare const cancelOrder: (orderId: string, orderCancel?: OrderCancel, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<cancelOrderResponse>;
+export type listOrderItemsResponse200 = {
+    data: OrderItemList;
+    status: 200;
+};
+export type listOrderItemsResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listOrderItemsResponseSuccess = listOrderItemsResponse200 & {
+    headers: Headers;
+};
+export type listOrderItemsResponseError = listOrderItemsResponseDefault & {
+    headers: Headers;
+};
+export type listOrderItemsResponse = listOrderItemsResponseSuccess | listOrderItemsResponseError;
+export declare const getListOrderItemsUrl: (orderId: string, params?: ListOrderItemsParams) => string;
+/**
+ * One entry per item bought, with the price charged and the period it covers.
+ * @summary List order items
+ */
+export declare const listOrderItems: (orderId: string, params?: ListOrderItemsParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listOrderItemsResponse>;
+export type listEntitlementsResponse200 = {
+    data: EntitlementList;
+    status: 200;
+};
+export type listEntitlementsResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listEntitlementsResponseSuccess = listEntitlementsResponse200 & {
+    headers: Headers;
+};
+export type listEntitlementsResponseError = listEntitlementsResponseDefault & {
+    headers: Headers;
+};
+export type listEntitlementsResponse = listEntitlementsResponseSuccess | listEntitlementsResponseError;
+export declare const getListEntitlementsUrl: (params?: ListEntitlementsParams) => string;
+/**
+ * Capabilities that come with what has been bought. A capability that is not held simply
+ * does not appear, so that "this does not exist" and "this has not been bought" cannot be
+ * confused.
+ *
+ * Derived from live subscriptions rather than stored, so this always agrees with what is
+ * being paid for. It stops being listed as soon as the subscription providing it ends.
+ * @summary List entitlements
+ */
+export declare const listEntitlements: (params?: ListEntitlementsParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listEntitlementsResponse>;
+export type listPricesResponse200 = {
+    data: PriceList;
+    status: 200;
+};
+export type listPricesResponse304 = {
+    data: void;
+    status: 304;
+};
+export type listPricesResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200 | 304>;
+};
+export type listPricesResponseSuccess = listPricesResponse200 & {
+    headers: Headers;
+};
+export type listPricesResponseError = (listPricesResponse304 | listPricesResponseDefault) & {
+    headers: Headers;
+};
+export type listPricesResponse = listPricesResponseSuccess | listPricesResponseError;
+export declare const getListPricesUrl: (params: ListPricesParams) => string;
+/**
+ * Every sellable thing and what it costs, in one request. A plan appears once per price.
+ *
+ * `currency` is required: a plan has a price in each currency it is sold in, so "what does
+ * this cost" has no answer without one.
+ *
+ * Archived prices are left out. Existing subscriptions keep the terms they were bought at, so
+ * this is not the place to look up what an existing purchase is paying.
+ * @summary List what is on sale, with prices
+ */
+export declare const listPrices: (params: ListPricesParams, headers?: ListPricesHeaders, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listPricesResponse>;
+export type listProductsResponse200 = {
+    data: ProductList;
+    status: 200;
+};
+export type listProductsResponse304 = {
+    data: NotModifiedResponse;
+    status: 304;
+};
+export type listProductsResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200 | 304>;
+};
+export type listProductsResponseSuccess = listProductsResponse200 & {
+    headers: Headers;
+};
+export type listProductsResponseError = (listProductsResponse304 | listProductsResponseDefault) & {
+    headers: Headers;
+};
+export type listProductsResponse = listProductsResponseSuccess | listProductsResponseError;
+export declare const getListProductsUrl: (params?: ListProductsParams) => string;
+/**
+ * @summary List catalog products
+ */
+export declare const listProducts: (params?: ListProductsParams, headers?: ListProductsHeaders, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listProductsResponse>;
+export type getProductResponse200 = {
+    data: Product;
+    status: 200;
+};
+export type getProductResponse304 = {
+    data: void;
+    status: 304;
+};
+export type getProductResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200 | 304>;
+};
+export type getProductResponseSuccess = getProductResponse200 & {
+    headers: Headers;
+};
+export type getProductResponseError = (getProductResponse304 | getProductResponseDefault) & {
+    headers: Headers;
+};
+export type getProductResponse = getProductResponseSuccess | getProductResponseError;
+export declare const getGetProductUrl: (productId: ProductID) => string;
+/**
+ * Resolves an identifier that was stored elsewhere — on an order line, an invoice line, or
+ * the terms of a credit — into something that can be displayed.
+ * @summary Get a service
+ */
+export declare const getProduct: (productId: ProductID, headers?: GetProductHeaders, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getProductResponse>;
+export type getPlanResponse200 = {
+    data: Plan;
+    status: 200;
+};
+export type getPlanResponse304 = {
+    data: void;
+    status: 304;
+};
+export type getPlanResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200 | 304>;
+};
+export type getPlanResponseSuccess = getPlanResponse200 & {
+    headers: Headers;
+};
+export type getPlanResponseError = (getPlanResponse304 | getPlanResponseDefault) & {
+    headers: Headers;
+};
+export type getPlanResponse = getPlanResponseSuccess | getPlanResponseError;
+export declare const getGetPlanUrl: (planId: string) => string;
+/**
+ * Resolves a stored identifier into something that can be displayed. Returns items that are
+ * no longer on sale: an existing purchase still refers to one.
+ * @summary Get a sellable item
+ */
+export declare const getPlan: (planId: string, headers?: GetPlanHeaders, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getPlanResponse>;
+export type getPriceResponse200 = {
+    data: Price;
+    status: 200;
+};
+export type getPriceResponse304 = {
+    data: void;
+    status: 304;
+};
+export type getPriceResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200 | 304>;
+};
+export type getPriceResponseSuccess = getPriceResponse200 & {
+    headers: Headers;
+};
+export type getPriceResponseError = (getPriceResponse304 | getPriceResponseDefault) & {
+    headers: Headers;
+};
+export type getPriceResponse = getPriceResponseSuccess | getPriceResponseError;
+export declare const getGetPriceUrl: (priceId: string) => string;
+/**
+ * Returns the catalog price, including archived prices. Fixed purchase history and renewal agreements are shown on orders and subscriptions rather than reconstructed from today's catalog.
+ * @summary Get a price
+ */
+export declare const getPrice: (priceId: string, headers?: GetPriceHeaders, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getPriceResponse>;
+export type listPlansResponse200 = {
+    data: PlanList;
+    status: 200;
+};
+export type listPlansResponse304 = {
+    data: NotModifiedResponse;
+    status: 304;
+};
+export type listPlansResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200 | 304>;
+};
+export type listPlansResponseSuccess = listPlansResponse200 & {
+    headers: Headers;
+};
+export type listPlansResponseError = (listPlansResponse304 | listPlansResponseDefault) & {
+    headers: Headers;
+};
+export type listPlansResponse = listPlansResponseSuccess | listPlansResponseError;
+export declare const getListPlansUrl: (params: ListPlansParams) => string;
+/**
+ * @summary List catalog plans
+ */
+export declare const listPlans: (params: ListPlansParams, headers?: ListPlansHeaders, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listPlansResponse>;
+export type listPricesByPlanResponse200 = {
+    data: PriceList;
+    status: 200;
+};
+export type listPricesByPlanResponse304 = {
+    data: NotModifiedResponse;
+    status: 304;
+};
+export type listPricesByPlanResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200 | 304>;
+};
+export type listPricesByPlanResponseSuccess = listPricesByPlanResponse200 & {
+    headers: Headers;
+};
+export type listPricesByPlanResponseError = (listPricesByPlanResponse304 | listPricesByPlanResponseDefault) & {
+    headers: Headers;
+};
+export type listPricesByPlanResponse = listPricesByPlanResponseSuccess | listPricesByPlanResponseError;
+export declare const getListPricesByPlanUrl: (planId: string, params?: ListPricesByPlanParams) => string;
+/**
+ * Public list prices only. An account holding a negotiated agreement may be charged less;
+ * it is never charged more.
+ * @summary List catalog prices
+ */
+export declare const listPricesByPlan: (planId: string, params?: ListPricesByPlanParams, headers?: ListPricesByPlanHeaders, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listPricesByPlanResponse>;
+export type listRatesResponse200 = {
+    data: RateList;
+    status: 200;
+};
+export type listRatesResponse304 = {
+    data: NotModifiedResponse;
+    status: 304;
+};
+export type listRatesResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200 | 304>;
+};
+export type listRatesResponseSuccess = listRatesResponse200 & {
+    headers: Headers;
+};
+export type listRatesResponseError = (listRatesResponse304 | listRatesResponseDefault) & {
+    headers: Headers;
+};
+export type listRatesResponse = listRatesResponseSuccess | listRatesResponseError;
+export declare const getListRatesUrl: (rateCardId: string, params?: ListRatesParams) => string;
+/**
+ * Only public price lists are readable here. A list written for a single agreement is not,
+ * and its identifier cannot be used to reach it.
+ * @summary List catalog rates
+ */
+export declare const listRates: (rateCardId: string, params?: ListRatesParams, headers?: ListRatesHeaders, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listRatesResponse>;
+export type listActiveResourcesResponse200 = {
+    data: ActiveResourceList;
+    status: 200;
+};
+export type listActiveResourcesResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listActiveResourcesResponseSuccess = listActiveResourcesResponse200 & {
+    headers: Headers;
+};
+export type listActiveResourcesResponseError = listActiveResourcesResponseDefault & {
+    headers: Headers;
+};
+export type listActiveResourcesResponse = listActiveResourcesResponseSuccess | listActiveResourcesResponseError;
+export declare const getListActiveResourcesUrl: (params?: ListActiveResourcesParams) => string;
+/**
+ * Lists continuous metering registrations paid for by your billing accounts. Their state does not
+ * describe machine runtime or health. Project filters narrow the authorized accounts; they do not
+ * grant project-based access.
+ * @summary List active resources
+ */
+export declare const listActiveResources: (params?: ListActiveResourcesParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listActiveResourcesResponse>;
+export type listSpendResponse200 = {
+    data: SpendRowList;
+    status: 200;
+};
+export type listSpendResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listSpendResponseSuccess = listSpendResponse200 & {
+    headers: Headers;
+};
+export type listSpendResponseError = listSpendResponseDefault & {
+    headers: Headers;
+};
+export type listSpendResponse = listSpendResponseSuccess | listSpendResponseError;
+export declare const getListSpendUrl: (params: ListSpendParams) => string;
+/**
+ * Aggregates rated and invoiced usage charges in the specified time range for one billing account.
+ * Includes usage not yet invoiced. Project filters use the account recorded on each charge, including
+ * charges for projects later assigned to another account. The total covers all matching groups, not
+ * just the returned page.
+ * @summary List account spend
+ */
+export declare const listSpend: (params: ListSpendParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listSpendResponse>;