@leaflow/sdk 0.0.0-dev.29.g8fe6a71 → 0.0.0-dev.293.g578f043

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

@@ -0,0 +1,1817 @@
+/**
+ * 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, CancelSubscriptionRequest, Cancellation, CancellationCreate, CancellationList, CheckoutOrderRequest, Contact, ContactCreate, ContactList, ContactUpdate, CreditGrantList, CreditNote, CreditNoteItemList, CreditNoteList, CurrencyList, DiscountList, EntitlementList, Error, ErrorResponse, GetPlanHeaders, GetPriceHeaders, GetProductHeaders, GetStatementUsageParams, Invoice, InvoiceItemList, InvoiceList, ListAccountDiscountsParams, ListActiveResourcesParams, ListAllowancesParams, ListBillingAccountsParams, ListCancellationsParams, ListContactsParams, 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, ListStatementsParams, ListSubscriptionsParams, ListTopUpsParams, ListTransactionsParams, ListUsageChargesParams, 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, Statement, StatementList, StatementSummary, 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 listContactsResponse200 = {
+    data: ContactList;
+    status: 200;
+};
+export type listContactsResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listContactsResponseSuccess = listContactsResponse200 & {
+    headers: Headers;
+};
+export type listContactsResponseError = listContactsResponseDefault & {
+    headers: Headers;
+};
+export type listContactsResponse = listContactsResponseSuccess | listContactsResponseError;
+export declare const getListContactsUrl: (accountId: number, params?: ListContactsParams) => string;
+/**
+ * @summary List contacts
+ */
+export declare const listContacts: (accountId: number, params?: ListContactsParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listContactsResponse>;
+export type createContactResponse201 = {
+    data: Contact;
+    status: 201;
+};
+export type createContactResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 201>;
+};
+export type createContactResponseSuccess = createContactResponse201 & {
+    headers: Headers;
+};
+export type createContactResponseError = createContactResponseDefault & {
+    headers: Headers;
+};
+export type createContactResponse = createContactResponseSuccess | createContactResponseError;
+export declare const getCreateContactUrl: (accountId: number) => string;
+/**
+ * @summary Create contact
+ */
+export declare const createContact: (accountId: number, contactCreate: ContactCreate, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<createContactResponse>;
+export type getContactResponse200 = {
+    data: Contact;
+    status: 200;
+};
+export type getContactResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getContactResponseSuccess = getContactResponse200 & {
+    headers: Headers;
+};
+export type getContactResponseError = getContactResponseDefault & {
+    headers: Headers;
+};
+export type getContactResponse = getContactResponseSuccess | getContactResponseError;
+export declare const getGetContactUrl: (contactId: string) => string;
+/**
+ * @summary Get contact
+ */
+export declare const getContact: (contactId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getContactResponse>;
+export type updateContactResponse200 = {
+    data: Contact;
+    status: 200;
+};
+export type updateContactResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type updateContactResponseSuccess = updateContactResponse200 & {
+    headers: Headers;
+};
+export type updateContactResponseError = updateContactResponseDefault & {
+    headers: Headers;
+};
+export type updateContactResponse = updateContactResponseSuccess | updateContactResponseError;
+export declare const getUpdateContactUrl: (contactId: string) => string;
+/**
+ * @summary Update contact
+ */
+export declare const updateContact: (contactId: string, contactUpdate: ContactUpdate, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<updateContactResponse>;
+export type deleteContactResponse204 = {
+    data: void;
+    status: 204;
+};
+export type deleteContactResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 204>;
+};
+export type deleteContactResponseSuccess = deleteContactResponse204 & {
+    headers: Headers;
+};
+export type deleteContactResponseError = deleteContactResponseDefault & {
+    headers: Headers;
+};
+export type deleteContactResponse = deleteContactResponseSuccess | deleteContactResponseError;
+export declare const getDeleteContactUrl: (contactId: string) => string;
+/**
+ * The selected invoice contact must be cleared or replaced before deletion. Issued invoice snapshots are retained.
+ * @summary Delete contact
+ */
+export declare const deleteContact: (contactId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<deleteContactResponse>;
+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;
+/**
+ * Select an active contact belonging to this account for future invoices. Its legal name,
+ * address and tax identifier are copied when an invoice is issued; issued snapshots are
+ * retained. Set invoice_contact_id to null to clear the selection. The currency cannot change.
+ * @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 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;
+/**
+ * Lists priced and unrated usage charges. Requires `statement_id`, `invoice_item_id`, or both `from` and `to` spanning at most 31 days; use the statement summary or spend report for longer periods. Charges are summed into one line per subscription, project, resource, meter and rate when their statement closes; filter by `invoice_item_id` to see the charges behind a line. Unrated charges had no applicable price when the usage occurred and are not billed.
+ *
+ * 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;
+/**
+ * Lists subscriptions visible to the authorized billing account. Soft-deleted subscriptions are excluded.
+ * @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;
+/**
+ * Returns a subscription visible to the authorized billing account. Soft-deleted subscriptions are reported as not found.
+ * @summary Get subscription
+ */
+export declare const getSubscription: (subscriptionId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getSubscriptionResponse>;
+export type deleteSubscriptionResponse204 = {
+    data: void;
+    status: 204;
+};
+export type deleteSubscriptionResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 204>;
+};
+export type deleteSubscriptionResponseSuccess = deleteSubscriptionResponse204 & {
+    headers: Headers;
+};
+export type deleteSubscriptionResponseError = deleteSubscriptionResponseDefault & {
+    headers: Headers;
+};
+export type deleteSubscriptionResponse = deleteSubscriptionResponseSuccess | deleteSubscriptionResponseError;
+export declare const getDeleteSubscriptionUrl: (subscriptionId: string) => string;
+/**
+ * Sets deleted_at on a canceled or terminated subscription, hiding it from your subscription
+ * list and detail. Your account access token must authorize the subscription's current billing
+ * account. Preserves commercial status, ended_at and billing and financial history. Completed
+ * cancellations and canceled unfulfilled purchases can be deleted directly, without termination.
+ * Pending, provisioning, active and suspended subscriptions are refused with 409
+ * BILLING_SUBSCRIPTION_NOT_ENDED and status in error params. A scheduled or releasing cancellation
+ * does not make a subscription canceled.
+ * There is no force, skip-cleanup or override option. Repeating deletion preserves the original
+ * deleted_at. Sends no cleanup command and creates no refund; outstanding cleanup continues.
+ * @summary Delete subscription
+ */
+export declare const deleteSubscription: (subscriptionId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<deleteSubscriptionResponse>;
+export type cancelSubscriptionResponse202 = {
+    data: Cancellation;
+    status: 202;
+};
+export type cancelSubscriptionResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 202>;
+};
+export type cancelSubscriptionResponseSuccess = cancelSubscriptionResponse202 & {
+    headers: Headers;
+};
+export type cancelSubscriptionResponseError = cancelSubscriptionResponseDefault & {
+    headers: Headers;
+};
+export type cancelSubscriptionResponse = cancelSubscriptionResponseSuccess | cancelSubscriptionResponseError;
+export declare const getCancelSubscriptionUrl: (subscriptionId: string) => string;
+/**
+ * Requests cancellation on the purchase's agreed terms. Uses the same quotation, eligibility,
+ * metering and original-payment-source refund rules as creating a cancellation.
+ * Supply the refund amount from create-quote with this subscription in cancellation.subscription_ids.
+ * Your account access token must authorize the subscription's current billing account.
+ *
+ * Immediate cancellation asks the owning service to clean up now. Period-end cancellation keeps
+ * the subscription active or suspended until the paid term ends. Neither payment nor acceptance
+ * of this request proves cleanup. The subscription becomes canceled only after the service
+ * confirms release and the end of metering; follow the returned cancellation for progress.
+ *
+ * Related subscriptions released together must be submitted as one group to create-cancellation.
+ * Pending or provisioning purchases are canceled through their order, not this operation.
+ * Repeating the same open cancellation returns it without another refund or command.
+ * @summary Cancel subscription
+ */
+export declare const cancelSubscription: (subscriptionId: string, cancelSubscriptionRequest: CancelSubscriptionRequest, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<cancelSubscriptionResponse>;
+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;
+/**
+ * Sums priced usage for one billing account by UTC day, including usage not yet invoiced. Amounts are
+ * before tax and before the tier adjustments made when a statement closes; minimum charges added at
+ * closing are included. `from` and `to` must fall on UTC day boundaries and span at most 92 days.
+ * 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>;
+export type listStatementsResponse200 = {
+    data: StatementList;
+    status: 200;
+};
+export type listStatementsResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listStatementsResponseSuccess = listStatementsResponse200 & {
+    headers: Headers;
+};
+export type listStatementsResponseError = listStatementsResponseDefault & {
+    headers: Headers;
+};
+export type listStatementsResponse = listStatementsResponseSuccess | listStatementsResponseError;
+export declare const getListStatementsUrl: (params?: ListStatementsParams) => string;
+/**
+ * @summary List statements
+ */
+export declare const listStatements: (params?: ListStatementsParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listStatementsResponse>;
+export type getStatementResponse200 = {
+    data: Statement;
+    status: 200;
+};
+export type getStatementResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getStatementResponseSuccess = getStatementResponse200 & {
+    headers: Headers;
+};
+export type getStatementResponseError = getStatementResponseDefault & {
+    headers: Headers;
+};
+export type getStatementResponse = getStatementResponseSuccess | getStatementResponseError;
+export declare const getGetStatementUrl: (statementId: string) => string;
+/**
+ * @summary Get statement
+ */
+export declare const getStatement: (statementId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getStatementResponse>;
+export type getStatementUsageResponse200 = {
+    data: StatementSummary;
+    status: 200;
+};
+export type getStatementUsageResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getStatementUsageResponseSuccess = getStatementUsageResponse200 & {
+    headers: Headers;
+};
+export type getStatementUsageResponseError = getStatementUsageResponseDefault & {
+    headers: Headers;
+};
+export type getStatementUsageResponse = getStatementUsageResponseSuccess | getStatementUsageResponseError;
+export declare const getGetStatementUsageUrl: (statementId: string, params?: GetStatementUsageParams) => string;
+/**
+ * Reads the consumption summary that is updated in the same transaction as usage is priced. Group by project, product or meter and filter within the statement. Quantities are included only for meter groups so different units are never combined.
+ * @summary Get grouped consumption
+ */
+export declare const getStatementUsage: (statementId: string, params?: GetStatementUsageParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getStatementUsageResponse>;