@leaflow/sdk 0.106.0 → 0.107.0

package/dist/gen/billing/account/v1/functions.d.ts

@@ -0,0 +1,1379 @@
+/**
+ * Generated by orval 🍺
+ * Do not edit manually.
+ * Leaflow Billing Account API
+ * The caller's billing accounts, purchases and payments.
+ * Query accepted financial operations by their original IDs after an unknown outcome.
+ * Public prices and estimates are served under `/catalog/v1/` and require no credentials.
+ * OpenAPI spec version: 1.0.0
+ */
+import type { AccountBalance } from "./models/accountBalance.js";
+import type { AllowanceList } from "./models/allowanceList.js";
+import type { AutoRenewSet } from "./models/autoRenewSet.js";
+import type { BillingAccount } from "./models/billingAccount.js";
+import type { BillingAccountCreate } from "./models/billingAccountCreate.js";
+import type { BillingAccountList } from "./models/billingAccountList.js";
+import type { BillingAccountUpdate } from "./models/billingAccountUpdate.js";
+import type { Cancellation } from "./models/cancellation.js";
+import type { CancellationCreate } from "./models/cancellationCreate.js";
+import type { CancellationList } from "./models/cancellationList.js";
+import type { CheckoutOrderRequest } from "./models/checkoutOrderRequest.js";
+import type { CreditGrantList } from "./models/creditGrantList.js";
+import type { CurrencyList } from "./models/currencyList.js";
+import type { DiscountList } from "./models/discountList.js";
+import type { EntitlementList } from "./models/entitlementList.js";
+import type { Error } from "./models/error.js";
+import type { ErrorResponse } from "./models/errorResponse.js";
+import type { Invoice } from "./models/invoice.js";
+import type { InvoiceItemList } from "./models/invoiceItemList.js";
+import type { InvoiceList } from "./models/invoiceList.js";
+import type { ListAccountDiscountsParams } from "./models/listAccountDiscountsParams.js";
+import type { ListAllowancesParams } from "./models/listAllowancesParams.js";
+import type { ListBillingAccountsParams } from "./models/listBillingAccountsParams.js";
+import type { ListCancellationsParams } from "./models/listCancellationsParams.js";
+import type { ListCreditGrantsParams } from "./models/listCreditGrantsParams.js";
+import type { ListCurrenciesParams } from "./models/listCurrenciesParams.js";
+import type { ListEntitlementsParams } from "./models/listEntitlementsParams.js";
+import type { ListInvoiceItemsParams } from "./models/listInvoiceItemsParams.js";
+import type { ListInvoicesParams } from "./models/listInvoicesParams.js";
+import type { ListOrderItemsParams } from "./models/listOrderItemsParams.js";
+import type { ListOrdersParams } from "./models/listOrdersParams.js";
+import type { ListPaymentMethodsParams } from "./models/listPaymentMethodsParams.js";
+import type { ListPaymentOptionsParams } from "./models/listPaymentOptionsParams.js";
+import type { ListProjectAssignmentsParams } from "./models/listProjectAssignmentsParams.js";
+import type { ListRefundsParams } from "./models/listRefundsParams.js";
+import type { ListRenewalPricesParams } from "./models/listRenewalPricesParams.js";
+import type { ListSubscriptionsParams } from "./models/listSubscriptionsParams.js";
+import type { ListTopUpsParams } from "./models/listTopUpsParams.js";
+import type { ListTransactionsParams } from "./models/listTransactionsParams.js";
+import type { ListUsageChargesParams } from "./models/listUsageChargesParams.js";
+import type { MeteredUsage } from "./models/meteredUsage.js";
+import type { Order } from "./models/order.js";
+import type { OrderItemList } from "./models/orderItemList.js";
+import type { OrderList } from "./models/orderList.js";
+import type { PayInvoiceRequest } from "./models/payInvoiceRequest.js";
+import type { PayTogetherRequest } from "./models/payTogetherRequest.js";
+import type { PaymentMethod } from "./models/paymentMethod.js";
+import type { PaymentMethodList } from "./models/paymentMethodList.js";
+import type { PaymentMethodSetup } from "./models/paymentMethodSetup.js";
+import type { PaymentMethodSetupResult } from "./models/paymentMethodSetupResult.js";
+import type { PaymentOptionList } from "./models/paymentOptionList.js";
+import type { PaymentPreview } from "./models/paymentPreview.js";
+import type { PaymentResult } from "./models/paymentResult.js";
+import type { PreviewInvoicePaymentParams } from "./models/previewInvoicePaymentParams.js";
+import type { ProjectAssignment } from "./models/projectAssignment.js";
+import type { ProjectAssignmentList } from "./models/projectAssignmentList.js";
+import type { Quote } from "./models/quote.js";
+import type { QuoteRequest } from "./models/quoteRequest.js";
+import type { RefundList } from "./models/refundList.js";
+import type { RenewRequest } from "./models/renewRequest.js";
+import type { RenewalOrderRequest } from "./models/renewalOrderRequest.js";
+import type { RenewalPriceList } from "./models/renewalPriceList.js";
+import type { SetProjectAssignmentRequest } from "./models/setProjectAssignmentRequest.js";
+import type { Subscription } from "./models/subscription.js";
+import type { SubscriptionList } from "./models/subscriptionList.js";
+import type { TopUp } from "./models/topUp.js";
+import type { TopUpCreate } from "./models/topUpCreate.js";
+import type { TopUpList } from "./models/topUpList.js";
+import type { TransactionList } from "./models/transactionList.js";
+import type { UsageChargeList } from "./models/usageChargeList.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 404 when the project has no billing account. No resources can be created until one is linked.
+ * @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;
+/**
+ * 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 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.
+ * @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;
+/**
+ * Computes a price preview without creating a resource or saving a quote. Nothing is charged,
+ * reserved or applied to an order, and no discount redemption is consumed. The response has no
+ * quote ID and does not guarantee a price or reserve a promotion code.
+ *
+ * With order_id, uses that order's recorded purchase terms and billing account. An optional
+ * promotion_code previews one code; without it, Billing selects an applicable account discount.
+ * An invalid or inapplicable explicit code is refused rather than silently replaced. Give total
+ * as expected_amount when confirming checkout; eligibility and availability are checked again.
+ * An order already checked out returns its confirmed amounts, without reapplying its discount;
+ * a different code is refused with BILLING_ORDER_CHECKOUT_CONFLICT.
+ *
+ * A renewal is priced exactly as renewing would charge it: at the agreed amount or the price
+ * named, with the discounts the account holds, and with tax. A renewal list does not accept a
+ * promotion code because its entries create separate orders. To use a new code on a renewal,
+ * first create a renewal order and quote its checkout by order_id. Prices and discount eligibility
+ * may change between preview and confirmation.
+ *
+ * A cancellation is quoted as creating it would compute the refund, as of now and under the refund
+ * terms agreed when each subscription was bought. It is quoted on its own: combined with another target
+ * the request is refused with HTTP 400 `BILLING_PURCHASE_INVALID` and `meta.field`
+ * `cancellation`. It is refused with the same errors as creating the cancellation, except that the
+ * amount is not checked. Give the returned `cancellation.proration_date` and
+ * `cancellation.refundable_amount` when creating it.
+ *
+ * Orders must belong to one of your billing accounts. Every subscription in a renewal or cancellation
+ * quote must be paid for by the same one of your billing accounts; otherwise the
+ * request is refused with HTTP 400 `BILLING_PURCHASE_INVALID`. Returns 404 when a subscription does
+ * not exist, and 403 `BILLING_ACCOUNT_FORBIDDEN` when it is paid for by an account you do not own.
+ * @summary Quote order checkout, renewals or a cancellation
+ */
+export declare const createQuote: (quoteRequest: QuoteRequest, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<createQuoteResponse>;
+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 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 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;
+/**
+ * Withdraws an order that is not paid in full, and tells the service that placed it, so that
+ * nothing is delivered. An order with nothing paid becomes `canceled` and its invoice is voided.
+ * What was already paid toward it, from credit grants or the balance, is returned the way it was
+ * paid, and the order becomes `failed`; its invoice is voided once everything paid has been
+ * returned. Either way `cancel_reason` is `requested_by_customer`.
+ * Canceling an order that is already canceled or failed returns it unchanged.
+ *
+ * Refused with 409 and `BILLING_PAID_ORDER_NOT_CANCELABLE` once the invoice is paid in full,
+ * `BILLING_ORDER_ALREADY_ACCEPTED` once the order has been accepted,
+ * `BILLING_ORDER_PAYMENT_IN_FLIGHT` while an online payment for it is in progress, and
+ * `BILLING_SCHEDULED_CHANGE_NOT_CANCELABLE` for a change that takes effect at the end of the
+ * period, which only the service that placed it can call off.
+ * @summary Cancel order
+ */
+export declare const cancelOrder: (orderId: string, 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>;