@leaflow/sdk 0.0.0-dev.39.gc9098a0 → 0.0.0-dev.393.g846cd9d

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

@@ -0,0 +1,2186 @@
+/**
+ * Generated by orval 🍺
+ * Do not edit manually.
+ * Leaflow Billing API
+ * Products, prices, orders, subscriptions and account billing. Operations on a billing account require an account access token. The account, its balance, payment options and quotes are also readable by members of the projects it currently pays for; changing the account and moving its funds need the owner. Members of a project, as each operation states, can also read the project's billing account, subscriptions and orders, complete and pay for its purchases, quote purchases, changes, renewals and cancellations, and, with the project permission `billing:finance.manage` granted in IAM, renew, cancel and turn automatic renewal of its subscriptions on or off, change its billing account and read its costs. A member without the permission an operation needs is refused with 403 `PERMISSION_DENIED` and `meta.permission`; a caller who is not a member, with 403 `IAM_NOT_PROJECT_MEMBER`. Public catalogue operations declare no security requirement.
+ * OpenAPI spec version: v1
+ */
+import type { AccountBalance, AccountDeletionReadiness, ActiveResourceList, AllowanceList, AutoRenewSet, BillingAccount, BillingAccountCreate, BillingAccountList, BillingAccountUpdate, CancelSubscriptionRequest, Cancellation, CancellationCreate, CancellationList, CancellationPreviewRequest, CancellationRefundPreview, CheckoutSession, CheckoutSessionConfirm, CheckoutSessionCreate, CheckoutSessionItemList, CheckoutSessionList, CheckoutSessionResult, Contact, ContactCreate, ContactList, ContactUpdate, CreditGrantList, CreditNote, CreditNoteItemList, CreditNoteList, CurrencyList, DiscountList, EntitlementList, Error, ErrorResponse, FeatureGrantList, GetCheckoutSessionQuoteParams, GetPlanHeaders, GetPriceHeaders, GetProductHeaders, GetStatementUsageParams, Invoice, InvoiceItemList, InvoiceList, ListAccountDiscountsParams, ListActiveResourcesParams, ListAllowancesParams, ListBillingAccountsParams, ListCancellationsParams, ListCheckoutSessionItemsParams, ListCheckoutSessionsParams, ListContactsParams, ListCreditGrantsParams, ListCreditNoteItemsParams, ListCreditNotesParams, ListCurrenciesParams, ListEntitlementsParams, ListFeatureGrantsParams, ListInvoiceItemsParams, ListInvoicesParams, ListMonthlyStatementsParams, ListOrderItemsParams, ListOrdersParams, ListPaymentMethodsParams, ListPaymentOptionsParams, ListPlansHeaders, ListPlansParams, ListPricesByPlanHeaders, ListPricesByPlanParams, ListPricesHeaders, ListPricesParams, ListProductsHeaders, ListProductsParams, ListProjectAssignmentsParams, ListRatesHeaders, ListRatesParams, ListRefundsParams, ListRenewalPricesParams, ListSpendParams, ListStatementsParams, ListSubscriptionsParams, ListTopUpsParams, ListTransactionsParams, ListUsageChargesParams, ListWithdrawalItemsParams, ListWithdrawalsParams, MonthlyStatementList, NotModifiedResponse, Order, OrderCancel, OrderItemList, OrderList, OrderRefundPreview, PayInvoiceRequest, PayTogetherRequest, PaymentMethod, PaymentMethodList, PaymentMethodSetup, PaymentMethodSetupResult, PaymentOptionList, PaymentPreview, PaymentResult, Plan, PlanList, PreviewInvoicePaymentParams, PreviewOrderRefundParams, Price, PriceList, PriceSearch, Product, ProductID, ProductList, ProjectAssignment, ProjectAssignmentList, Quote, QuoteRequest, RateList, RateSearch, RefundList, RenewRequest, RenewalPriceList, SetProjectAssignmentRequest, SpendRowList, Statement, StatementList, StatementSummary, Subscription, SubscriptionList, TopUp, TopUpCreate, TopUpList, TransactionList, UsageChargeList, UsageEstimate, UsageEstimateRequest, Withdrawal, WithdrawalCreate, WithdrawalItemList, WithdrawalList, WithdrawalPreview, WithdrawalPreviewRequest } 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 listWithdrawalItemsResponse200 = {
+    data: WithdrawalItemList;
+    status: 200;
+};
+export type listWithdrawalItemsResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listWithdrawalItemsResponseSuccess = listWithdrawalItemsResponse200 & {
+    headers: Headers;
+};
+export type listWithdrawalItemsResponseError = listWithdrawalItemsResponseDefault & {
+    headers: Headers;
+};
+export type listWithdrawalItemsResponse = listWithdrawalItemsResponseSuccess | listWithdrawalItemsResponseError;
+export declare const getListWithdrawalItemsUrl: (withdrawalId: string, params?: ListWithdrawalItemsParams) => string;
+/**
+ * The withdrawal's items and their outcomes. A failed item does not undo refunds completed through other items.
+ * @summary List withdrawal items
+ */
+export declare const listWithdrawalItems: (withdrawalId: string, params?: ListWithdrawalItemsParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listWithdrawalItemsResponse>;
+export type listWithdrawalsResponse200 = {
+    data: WithdrawalList;
+    status: 200;
+};
+export type listWithdrawalsResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listWithdrawalsResponseSuccess = listWithdrawalsResponse200 & {
+    headers: Headers;
+};
+export type listWithdrawalsResponseError = listWithdrawalsResponseDefault & {
+    headers: Headers;
+};
+export type listWithdrawalsResponse = listWithdrawalsResponseSuccess | listWithdrawalsResponseError;
+export declare const getListWithdrawalsUrl: (params?: ListWithdrawalsParams) => string;
+/**
+ * Withdrawals, newest first.
+ * @summary List withdrawals
+ */
+export declare const listWithdrawals: (params?: ListWithdrawalsParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listWithdrawalsResponse>;
+export type createWithdrawalResponse201 = {
+    data: Withdrawal;
+    status: 201;
+};
+export type createWithdrawalResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 201>;
+};
+export type createWithdrawalResponseSuccess = createWithdrawalResponse201 & {
+    headers: Headers;
+};
+export type createWithdrawalResponseError = createWithdrawalResponseDefault & {
+    headers: Headers;
+};
+export type createWithdrawalResponse = createWithdrawalResponseSuccess | createWithdrawalResponseError;
+export declare const getCreateWithdrawalUrl: () => string;
+/**
+ * Withdraws the requested balance through the original top-ups, oldest first, with fees calculated per source. expected_items and expected_refund_amount must match the preview. Reusing the ID with different terms fails. Only successful items are charged a fee.
+ * @summary Create withdrawal
+ */
+export declare const createWithdrawal: (withdrawalCreate: WithdrawalCreate, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<createWithdrawalResponse>;
+export type previewWithdrawalResponse200 = {
+    data: WithdrawalPreview;
+    status: 200;
+};
+export type previewWithdrawalResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type previewWithdrawalResponseSuccess = previewWithdrawalResponse200 & {
+    headers: Headers;
+};
+export type previewWithdrawalResponseError = previewWithdrawalResponseDefault & {
+    headers: Headers;
+};
+export type previewWithdrawalResponse = previewWithdrawalResponseSuccess | previewWithdrawalResponseError;
+export declare const getPreviewWithdrawalUrl: () => string;
+/**
+ * Previews the balance deduction, fees and refund split by original top-up. Omit amount to preview all available balance. Nothing is created or reserved. Fails when a selected source has no refund route or its original processing cost is not yet known.
+ * @summary Preview withdrawal
+ */
+export declare const previewWithdrawal: (withdrawalPreviewRequest: WithdrawalPreviewRequest, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<previewWithdrawalResponse>;
+export type getWithdrawalResponse200 = {
+    data: Withdrawal;
+    status: 200;
+};
+export type getWithdrawalResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getWithdrawalResponseSuccess = getWithdrawalResponse200 & {
+    headers: Headers;
+};
+export type getWithdrawalResponseError = getWithdrawalResponseDefault & {
+    headers: Headers;
+};
+export type getWithdrawalResponse = getWithdrawalResponseSuccess | getWithdrawalResponseError;
+export declare const getGetWithdrawalUrl: (withdrawalId: string) => string;
+/**
+ * A withdrawal with its accepted amounts and overall outcome; list its items for each refund result.
+ * @summary Get withdrawal
+ */
+export declare const getWithdrawal: (withdrawalId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getWithdrawalResponse>;
+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;
+/**
+ * Contacts of the billing account, inactive ones included. Returns 404 if the account does not exist.
+ * @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;
+/**
+ * Creates a contact for the billing account. To use it on invoices, set the account's invoice_contact_id.
+ * @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: (accountId: number, contactId: string) => string;
+/**
+ * A contact of this billing account. Returns 404 if it does not exist in the account.
+ * @summary Get contact
+ */
+export declare const getContact: (accountId: number, 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: (accountId: number, contactId: string) => string;
+/**
+ * Updates a contact of this billing account. Returns 404 if it does not exist in the account.
+ * @summary Update contact
+ */
+export declare const updateContact: (accountId: number, 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: (accountId: number, contactId: string) => string;
+/**
+ * Deletes a contact of this billing account; 404 if it does not exist in the account. A contact selected for invoices must be cleared or replaced first. Issued invoices keep their copy.
+ * @summary Delete contact
+ */
+export declare const deleteContact: (accountId: number, 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;
+/**
+ * Currencies a new billing account can be opened in, and prices and quotes without an account can be given in, for anyone, signed in or not. Retired currencies are not listed.
+ * @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;
+/**
+ * Billing accounts owned by the authenticated user.
+ * @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;
+/**
+ * Creates a billing account. Its currency is fixed: prices, orders, invoices and balance are all in it.
+ * @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;
+/**
+ * A billing account with its currency, status and invoice contact, readable by its owner and by members of the projects it currently pays for. Returns 404 if it does not exist and 403 to anyone else.
+ * @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;
+/**
+ * Selects an active contact of this account for future invoices; its legal name, address and tax identifier are copied when an invoice is issued. Set invoice_contact_id to null to clear it. 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 suspendBillingAccountResponse200 = {
+    data: BillingAccount;
+    status: 200;
+};
+export type suspendBillingAccountResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type suspendBillingAccountResponseSuccess = suspendBillingAccountResponse200 & {
+    headers: Headers;
+};
+export type suspendBillingAccountResponseError = suspendBillingAccountResponseDefault & {
+    headers: Headers;
+};
+export type suspendBillingAccountResponse = suspendBillingAccountResponseSuccess | suspendBillingAccountResponseError;
+export declare const getSuspendBillingAccountUrl: (accountId: number) => string;
+/**
+ * Suspends your active billing account without closing it, also while it is in arrears. While suspended, it
+ * accepts no new purchases, renewals or project links, and the services it pays for start no new resources;
+ * running services, their charges and the handling of arrears continue, and you can still top up and pay
+ * invoices. Resume it yourself; one suspended by Leaflow can only be resumed by Leaflow. Does not create a
+ * resource.
+ * @summary Suspend billing account
+ */
+export declare const suspendBillingAccount: (accountId: number, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<suspendBillingAccountResponse>;
+export type resumeBillingAccountResponse200 = {
+    data: BillingAccount;
+    status: 200;
+};
+export type resumeBillingAccountResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type resumeBillingAccountResponseSuccess = resumeBillingAccountResponse200 & {
+    headers: Headers;
+};
+export type resumeBillingAccountResponseError = resumeBillingAccountResponseDefault & {
+    headers: Headers;
+};
+export type resumeBillingAccountResponse = resumeBillingAccountResponseSuccess | resumeBillingAccountResponseError;
+export declare const getResumeBillingAccountUrl: (accountId: number) => string;
+/**
+ * Resumes a billing account you suspended. Refused with `BILLING_ACCOUNT_SUSPENDED_BY_OPERATOR` when Leaflow
+ * suspended it. Does not create a resource.
+ * @summary Resume billing account
+ */
+export declare const resumeBillingAccount: (accountId: number, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<resumeBillingAccountResponse>;
+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;
+/**
+ * The balance of an account, with credit groups, unpaid invoice amounts, unbilled estimates and pending returns, readable by its owner and by members of the projects it currently pays for. Returns 404 for a missing account and 403 to anyone else.
+ * @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;
+/**
+ * The payment gateways and methods currently accepting the account's currency, preferred gateway first. Top-ups and invoice payments must use one listed here. An empty result means online payment is unavailable for the account. Open to the owner of the account and to members of the projects it currently pays for.
+ * @summary List payment options
+ */
+export declare const listPaymentOptions: (accountId: number, params?: ListPaymentOptionsParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listPaymentOptionsResponse>;
+export type getAccountDeletionReadinessResponse200 = {
+    data: AccountDeletionReadiness;
+    status: 200;
+};
+export type getAccountDeletionReadinessResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getAccountDeletionReadinessResponseSuccess = getAccountDeletionReadinessResponse200 & {
+    headers: Headers;
+};
+export type getAccountDeletionReadinessResponseError = getAccountDeletionReadinessResponseDefault & {
+    headers: Headers;
+};
+export type getAccountDeletionReadinessResponse = getAccountDeletionReadinessResponseSuccess | getAccountDeletionReadinessResponseError;
+export declare const getGetAccountDeletionReadinessUrl: () => string;
+/**
+ * Lists every billing account you own that is not closed, with what stops each from closing. Deleting your Leaflow
+ * account closes all of them and is refused while any lists an objection. Balance and credits left on them are
+ * forfeited when they close; the accounts and their records are kept, closed.
+ *
+ * A preview that holds nothing: the same check runs again when you request deletion and once more when the grace
+ * period ends.
+ * @summary Check billing accounts before deleting your Leaflow account
+ */
+export declare const getAccountDeletionReadiness: (options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getAccountDeletionReadinessResponse>;
+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;
+/**
+ * Current project assignments to your billing accounts, filtered by billing_account_id or project_ids. Past charges keep the account they were assigned to.
+ * @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;
+/**
+ * The project's current assignment, readable by the owner of the assigned account and by members of the project. Returns 404 when no billing account is assigned; the project cannot create resources until one is.
+ * @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;
+/**
+ * Links the project to a billing account you own; you need the project permission
+ * `billing:finance.manage`. A project without one is linked directly. Moving it to another
+ * account has the same requirements as unlinking: you own both accounts, the project has no metered resources,
+ * no subscriptions that have not ended and no orders in progress, and the current account has no unpaid
+ * invoices. Nothing moves with the project; charges already incurred stay with the account linked when they
+ * occurred.
+ *
+ * Refused once the project no longer accepts purchases because it is being deleted.
+ * @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; the assignment history is kept. You need to own the account and hold the project permission `billing:finance.manage`. Allowed only when the project has no metered resources, no subscriptions that have not ended and no orders in progress, including period-end changes, and the billing account has no unpaid invoices; invoices of orders awaiting payment do not count. Orders are not modified, so wait for them to complete. Charges already incurred stay with the billing account and are invoiced as usual. 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;
+/**
+ * Your top-ups, including pending, failed and canceled attempts. 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 of the authenticated user and returns its payment information. The balance increases when the gateway confirms receipt. Keep the supplied ID to read the attempt after a lost response; creating it again 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;
+/**
+ * A top-up of the authenticated user, with its outcome and unspent amount. While it is pending, `action` carries the customer's next step as the gateway reports it, so an interrupted payment can be continued; when the gateway cannot be reached, `action` is omitted.
+ * @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 of the authenticated user at the payment gateway. It becomes `canceled` with
+ * `cancellation_reason` `requested_by_customer`, and nothing is collected. Canceling a canceled top-up returns
+ * it unchanged. If the gateway has already collected the payment, the top-up is returned as `succeeded` with the
+ * balance increased; check `status` in the response.
+ *
+ * Fails with 409 `BILLING_TOPUP_NOT_CANCELABLE` when the top-up has succeeded or failed, with `status` naming
+ * the outcome, or while the gateway is processing the payment, with `status` `pending`; read the top-up again
+ * later.
+ * @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;
+/**
+ * Saved payment methods of your billing accounts, optionally for one billing_account_id. Removed methods are not listed.
+ * @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 the browser needs to open the payment gateway's card form. Nothing is charged; the method is listed once the gateway confirms it. Card numbers never reach 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;
+/**
+ * Makes an active saved payment method the default for its billing account and returns it. Expired or removed methods cannot be selected; selecting the current default changes nothing.
+ * @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 payment method of an account with metered resources.
+ * @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;
+/**
+ * Pays the invoice from eligible credit grants and balance as requested, and collects the remainder through the
+ * selected gateway and method. Without a gateway, insufficient funds fail and no online payment starts. The
+ * invoice's amounts and discount were fixed when it was issued and are not changed by paying; promotion codes
+ * are applied when completing a Checkout Session.
+ *
+ * Returns a payment action when the customer must act; requires_action and processing are not paid. An
+ * unresolved online payment with the same gateway, method and saved payment method is reused, and retries never
+ * apply credit grants or balance twice. Paying any other way first cancels that payment; if the gateway had
+ * already collected it, the invoice is paid by it and nothing more is charged. A payment the gateway is still
+ * processing fails with `BILLING_PAYMENT_PENDING` and `meta.transaction_id`.
+ *
+ * A paid invoice returns its existing result without another charge. Refused with `BILLING_INVOICE_NOT_PAYABLE`
+ * for a void invoice; `BILLING_ORDER_FAILED` or `BILLING_ORDER_CANCELED` for the invoice of a failed or canceled
+ * order; `BILLING_ORDER_EXPIRED` after the order's payment deadline; `BILLING_INVOICE_NOT_PAYABLE` with
+ * `meta.reason` `subscription_canceling`, `subscription_reclaiming` or `subscription_ended` for a renewal
+ * invoice whose subscription is being canceled, is being reclaimed or has ended; and
+ * `BILLING_INVOICE_NOT_PAYABLE` with `meta.reason` `fractional_amount` when the amount left for the gateway is
+ * not a whole number of the currency's minor unit; such an invoice is collected from credit grants and balance
+ * automatically, including right after a top-up.
+ *
+ * Open to the owner of the invoice's billing account and, for the invoice of an order of a project, to members
+ * of the project. Only the owner can pay with a saved `payment_method_id`.
+ * @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. Open to the same callers as paying.
+ * @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 those of the listed orders, from eligible credit grants and then balance,
+ * without a payment gateway.
+ *
+ * All invoices are paid or none: insufficient funds fail with `BILLING_INSUFFICIENT_FUNDS`, and a total other
+ * than expected_amount fails with `BILLING_AMOUNT_CHANGED`, charging nothing. Paid invoices are not charged
+ * again. An earlier online payment for one of the invoices is canceled first; one the gateway is still
+ * processing is refused with `BILLING_PAYMENT_PENDING` and `meta.transaction_id`. Also refused with
+ * `BILLING_INVOICE_NOT_PAYABLE` for a void invoice; `BILLING_ORDER_FAILED`, `BILLING_ORDER_CANCELED` or `BILLING_ORDER_EXPIRED` for an order in that
+ * state; and `BILLING_INVOICE_NOT_PAYABLE` with `meta.reason` `subscription_canceling`,
+ * `subscription_reclaiming` or `subscription_ended` for a renewal invoice of a subscription being canceled,
+ * being reclaimed or ended.
+ * @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, per invoice in payment order, calculated as paying together does. Nothing is charged, reserved or created. Refused with the same errors as paying together, except that insufficient funds show as a `gateway_amount` above zero instead of an error.
+ * @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;
+/**
+ * Issued invoices of your billing accounts. Top-ups have no invoices.
+ * @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;
+/**
+ * An issued invoice of your billing account, or the invoice of an order of a project you are a member of, with its amounts, tax lines and payment state. A missing or unissued invoice returns 404; any other invoice returns 403.
+ * @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;
+/**
+ * Lines of an invoice readable with get-invoice, with their service periods and projects. A missing or unissued invoice returns 404; any other invoice returns 403.
+ * @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;
+/**
+ * Ledger entries of your billing accounts, filtered by billing_account_id and creation time.
+ * @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 held by the account, applied at checkout without a code. Coupons reached through a code are not listed.
+ * @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;
+/**
+ * Credit grants with what remains and what each may pay for. Credit is spent before 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;
+/**
+ * Credit notes, newest first. Filters apply within the billing accounts you are authorized for.
+ * @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 invoice lines this credit note reduced.
+ * @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;
+/**
+ * Priced usage charges in the requested scope; members with the project permission `billing:finance.manage` list a project's charges with `project_ids`. Usage that had no price when it occurred is never charged later.
+ * @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;
+/**
+ * Subscriptions paid by your billing accounts; members of a project list its subscriptions with `project_ids`. Deleted subscriptions are not listed.
+ * @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;
+/**
+ * A subscription paid by your billing account or of a project you are a member of. 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;
+/**
+ * Hides a canceled or terminated subscription from your subscription list and detail by setting deleted_at; its status, ended_at and history are kept. Only the owner of the subscription's current billing account can delete it. A subscription that has not ended is refused with 409 `BILLING_SUBSCRIPTION_NOT_ENDED` and `status`. Repeating it keeps the original deleted_at. It sends no cleanup command and creates no refund.
+ * @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, with the same rules as creating a cancellation. Give the
+ * refund amount from a quote with this subscription in `cancellation.subscription_ids`. Open to the owner of the
+ * subscription's current billing account and to members of its project with the project permission
+ * `billing:finance.manage`.
+ *
+ * Immediate cancellation asks the owning service to release the resources now; period-end cancellation keeps the
+ * subscription active or suspended until the paid term ends. The subscription becomes canceled when the service
+ * confirms the release; follow the returned cancellation. Subscriptions released together must be canceled
+ * together through create-cancellation, and pending or provisioning purchases through their order. Repeating the
+ * request while the cancellation is open returns it.
+ * @summary Cancel subscription
+ */
+export declare const cancelSubscription: (subscriptionId: string, cancelSubscriptionRequest: CancelSubscriptionRequest, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<cancelSubscriptionResponse>;
+export type getQuoteResponse200 = {
+    data: Quote;
+    status: 200;
+};
+export type getQuoteResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getQuoteResponseSuccess = getQuoteResponse200 & {
+    headers: Headers;
+};
+export type getQuoteResponseError = getQuoteResponseDefault & {
+    headers: Headers;
+};
+export type getQuoteResponse = getQuoteResponseSuccess | getQuoteResponseError;
+export declare const getGetQuoteUrl: () => string;
+/**
+ * Calculates what a proposed purchase, a change of your subscriptions or their renewal would invoice now, and
+ * what each purchased or changed line renews at. Nothing is saved, reserved or redeemed.
+ *
+ * With `billing_account_id`, the quote is for that billing account: its currency, account discounts,
+ * tax and funds apply, changes and renewals use the account currently paying for each subscription, and an
+ * access token is required. The account must be yours or currently pay for a project you are a member of.
+ * Without it, proposed items are priced in `currency` for anyone, signed in or not: no account discount or funds
+ * apply, and tax that would be added is included only for the customer's `address`.
+ *
+ * A change is priced as the service that owns the subscription would order it: pass the returned `total` as the
+ * expected amount and, for an immediate change, `proration_date` to that service when making the change.
+ *
+ * A promotion code is evaluated without being applied. It is applied only when a Checkout Session is completed
+ * with it; conditions that depend on the account, such as a first purchase, are checked only with an account
+ * and otherwise reported as `unverified`. Future usage of metered prices is estimated with `estimate-usage`.
+ * @summary Get a quote
+ */
+export declare const getQuote: (quoteRequest: QuoteRequest, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getQuoteResponse>;
+export type estimateUsageResponse200 = {
+    data: UsageEstimate;
+    status: 200;
+};
+export type estimateUsageResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type estimateUsageResponseSuccess = estimateUsageResponse200 & {
+    headers: Headers;
+};
+export type estimateUsageResponseError = estimateUsageResponseDefault & {
+    headers: Headers;
+};
+export type estimateUsageResponse = estimateUsageResponseSuccess | estimateUsageResponseError;
+export declare const getEstimateUsageUrl: () => string;
+/**
+ * Estimates what future usage of metered prices would cost in `currency` at current rates, for anyone, signed in
+ * or not. Nothing is saved. Graduated and volume tiers apply to the estimated quantity alone, while actual charges
+ * follow each month's whole usage, and the amounts are before discounts and tax. Estimates are not collected at
+ * checkout. An item that cannot be priced fails the whole request.
+ * @summary Estimate usage
+ */
+export declare const estimateUsage: (usageEstimateRequest: UsageEstimateRequest, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<estimateUsageResponse>;
+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; members of a project list its cancellations with `project_ids`. Filter by `subscription_id` and `status=open` to find a subscription's cancellation in progress.
+ * @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 subscriptions of one service together. Deleting a resource is an `immediate` cancellation of every
+ * subscription released with it, such as a server with its disks or an address with its bandwidth. Open to the
+ * owner of the subscriptions' current billing account and to members of their project with the project
+ * permission `billing:finance.manage`.
+ *
+ * The owning service releases the resources 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 to the original payment
+ * sources under each subscription's refund terms. For `immediate` the refund is computed as of `proration_date`
+ * and is not reduced by service used during release. Metered usage is charged until release.
+ *
+ * `mode` must be allowed for every subscription. Metered and one-time subscriptions end only `immediate`. A
+ * licensed subscription ends `period_end` while its paid term lasts, and `immediate` unless its terms allow only
+ * the end of the paid term and that term has not ended. For `period_end` all paid terms must end at the same
+ * time.
+ *
+ * Refused with:
+ *
+ * - 400 `BILLING_CANCELLATION_INVALID` when `subscription_ids` or `proration_date` is invalid (`meta.field`), or
+ *   the subscriptions do not share 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, and `BILLING_CANCELLATION_TERMS_UNSET`
+ *   when a licensed subscription has no cancellation terms, both with `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.reason` `reclaim_requested`), or has a paid change waiting to
+ *   switch (`meta.order_id`);
+ * - 409 `BILLING_ORDER_PAYMENT_IN_FLIGHT` while an online renewal payment for one of them is in progress;
+ * - 409 `BILLING_CANCELLATION_REFUND_CHANGED` when the refund no longer equals `expected_refundable_amount`.
+ *
+ * Repeating the request for the same subscriptions, mode and amount while the cancellation is open returns it
+ * with 200. Unpaid renewal orders are canceled with it, and automatic renewal is turned off for every
+ * subscription.
+ * @summary Cancel subscriptions
+ */
+export declare const createCancellation: (cancellationCreate: CancellationCreate, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<createCancellationResponse>;
+export type previewCancellationResponse200 = {
+    data: CancellationRefundPreview;
+    status: 200;
+};
+export type previewCancellationResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type previewCancellationResponseSuccess = previewCancellationResponse200 & {
+    headers: Headers;
+};
+export type previewCancellationResponseError = previewCancellationResponseDefault & {
+    headers: Headers;
+};
+export type previewCancellationResponse = previewCancellationResponseSuccess | previewCancellationResponseError;
+export declare const getPreviewCancellationUrl: () => string;
+/**
+ * What creating the cancellation now would return, per subscription and in total. Nothing is canceled, ended or refunded. Open to the owner of the subscriptions' current billing account and to members of their project; refused for the same states as creating it.
+ * @summary Preview a cancellation
+ */
+export declare const previewCancellation: (cancellationPreviewRequest: CancellationPreviewRequest, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<previewCancellationResponse>;
+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;
+/**
+ * A cancellation paid by your billing account or of a project you are a member of, with its schedule, expected refundable amount and the outcome for each subscription, including partial success.
+ * @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 no resource has begun to be released; afterwards it is refused with 409 `BILLING_CANCELLATION_CONFLICT`. The subscriptions continue, but automatic renewal, turned off when the cancellation was created, stays off until it is turned on again. Withdrawing a withdrawn cancellation returns it unchanged. Open to the owner of the subscriptions' current billing account and to members of their project with the project permission `billing:finance.manage`.
+ * @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. Open to the owner of the subscription's current billing account and to members of its project.
+ * @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;
+/**
+ * Buys licensed periods from current_term_end at the agreed recurring amount and pays for them at once. A
+ * different interval selects the price currently sold for it and fixes new terms on the order, applied after
+ * fulfillment. Paid periods keep their value.
+ *
+ * Without `payment_method_id`, the renewal is paid from credit grants and balance as `use_credits` and
+ * `use_balance` allow; when they cannot cover it, the request fails with `BILLING_INSUFFICIENT_FUNDS` and no
+ * order is left. To apply a promotion code or pay later, create a renewal Checkout Session.
+ *
+ * Open to the owner of the subscription's current billing account and to members of its project with the
+ * project permission `billing:finance.manage`. Only the owner can pay with `payment_method_id`.
+ *
+ * Keep order_id and read the order after an unknown outcome; creating it again conflicts.
+ * @summary Renew subscription
+ */
+export declare const renewSubscription: (subscriptionId: string, renewRequest: RenewRequest, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<renewSubscriptionResponse>;
+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;
+/**
+ * Turns automatic renewal of an active or suspended licensed subscription on or off. Turning it off does not shorten current_term_end and still allows manual renewal. Refused with 409 `BILLING_SUBSCRIPTION_AUTO_RENEW_INACTIVE` for a pending or provisioning subscription, 409 `BILLING_SUBSCRIPTION_AUTO_RENEW_FIXED` for a metered subscription, which continues until it is canceled, and 409 `BILLING_SUBSCRIPTION_OPERATION_PENDING` with `meta.cancellation_id` while a cancellation is open: creating it turned renewal off, and withdrawing it does not turn renewal back on. Open to the owner of the subscription's current billing account and to members of its project with the project permission `billing:finance.manage`.
+ * @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;
+/**
+ * Remaining usage quantities, such as bytes, seconds or tokens; members of a project list its allowances with `project_ids`. Applicable allowances are consumed before usage is charged: lower priority values first, then earlier expiry, then earlier issuance. Unused quantity expires without refund or carry-over. Promotional allowances apply to usage paid by their holding account; included allowances apply only to their subscription, also 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 listCheckoutSessionsResponse200 = {
+    data: CheckoutSessionList;
+    status: 200;
+};
+export type listCheckoutSessionsResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listCheckoutSessionsResponseSuccess = listCheckoutSessionsResponse200 & {
+    headers: Headers;
+};
+export type listCheckoutSessionsResponseError = listCheckoutSessionsResponseDefault & {
+    headers: Headers;
+};
+export type listCheckoutSessionsResponse = listCheckoutSessionsResponseSuccess | listCheckoutSessionsResponseError;
+export declare const getListCheckoutSessionsUrl: (params?: ListCheckoutSessionsParams) => string;
+/**
+ * Checkout Sessions of your billing accounts, newest first; members of a project list its sessions with `project_ids`. An open session is a purchase waiting for checkout to be completed.
+ * @summary List Checkout Sessions
+ */
+export declare const listCheckoutSessions: (params?: ListCheckoutSessionsParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listCheckoutSessionsResponse>;
+export type createCheckoutSessionResponse201 = {
+    data: CheckoutSession;
+    status: 201;
+};
+export type createCheckoutSessionResponse409 = {
+    data: Error;
+    status: 409;
+};
+export type createCheckoutSessionResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 201 | 409>;
+};
+export type createCheckoutSessionResponseSuccess = createCheckoutSessionResponse201 & {
+    headers: Headers;
+};
+export type createCheckoutSessionResponseError = (createCheckoutSessionResponse409 | createCheckoutSessionResponseDefault) & {
+    headers: Headers;
+};
+export type createCheckoutSessionResponse = createCheckoutSessionResponseSuccess | createCheckoutSessionResponseError;
+export declare const getCreateCheckoutSessionUrl: () => string;
+/**
+ * Opens a Checkout Session renewing a licensed subscription, with periods and price chosen as in
+ * renewing. Nothing is charged until you complete it, when a promotion code can be applied; it then renews from
+ * the subscription's current_term_end at that time. To renew at once from credit grants, balance or a payment
+ * method, renew the subscription instead. Purchases and changes of a service's resources are created through
+ * that service.
+ *
+ * Open to the owner of the subscription's current billing account and to members of its project with the
+ * project permission `billing:finance.manage`. Keep `checkout_session_id` and read the session after an
+ * unknown outcome; creating it again conflicts.
+ * @summary Create a renewal Checkout Session
+ */
+export declare const createCheckoutSession: (checkoutSessionCreate: CheckoutSessionCreate, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<createCheckoutSessionResponse>;
+export type getCheckoutSessionResponse200 = {
+    data: CheckoutSession;
+    status: 200;
+};
+export type getCheckoutSessionResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getCheckoutSessionResponseSuccess = getCheckoutSessionResponse200 & {
+    headers: Headers;
+};
+export type getCheckoutSessionResponseError = getCheckoutSessionResponseDefault & {
+    headers: Headers;
+};
+export type getCheckoutSessionResponse = getCheckoutSessionResponseSuccess | getCheckoutSessionResponseError;
+export declare const getGetCheckoutSessionUrl: (checkoutSessionId: string) => string;
+/**
+ * A Checkout Session of your billing account or of a project you are a member of. Poll it to follow checkout; once it is complete, read its order for payment and delivery. An unknown session returns 404; any other session returns 403.
+ * @summary Get a Checkout Session
+ */
+export declare const getCheckoutSession: (checkoutSessionId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getCheckoutSessionResponse>;
+export type listCheckoutSessionItemsResponse200 = {
+    data: CheckoutSessionItemList;
+    status: 200;
+};
+export type listCheckoutSessionItemsResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listCheckoutSessionItemsResponseSuccess = listCheckoutSessionItemsResponse200 & {
+    headers: Headers;
+};
+export type listCheckoutSessionItemsResponseError = listCheckoutSessionItemsResponseDefault & {
+    headers: Headers;
+};
+export type listCheckoutSessionItemsResponse = listCheckoutSessionItemsResponseSuccess | listCheckoutSessionItemsResponseError;
+export declare const getListCheckoutSessionItemsUrl: (checkoutSessionId: string, params?: ListCheckoutSessionItemsParams) => string;
+/**
+ * What the session buys, by position. Prices and amounts are in its quote. Readable by whoever can read the session.
+ * @summary List Checkout Session items
+ */
+export declare const listCheckoutSessionItems: (checkoutSessionId: string, params?: ListCheckoutSessionItemsParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listCheckoutSessionItemsResponse>;
+export type getCheckoutSessionQuoteResponse200 = {
+    data: Quote;
+    status: 200;
+};
+export type getCheckoutSessionQuoteResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getCheckoutSessionQuoteResponseSuccess = getCheckoutSessionQuoteResponse200 & {
+    headers: Headers;
+};
+export type getCheckoutSessionQuoteResponseError = getCheckoutSessionQuoteResponseDefault & {
+    headers: Headers;
+};
+export type getCheckoutSessionQuoteResponse = getCheckoutSessionQuoteResponseSuccess | getCheckoutSessionQuoteResponseError;
+export declare const getGetCheckoutSessionQuoteUrl: (checkoutSessionId: string, params?: GetCheckoutSessionQuoteParams) => string;
+/**
+ * What completing this open session now would invoice, with `promotion_code` or otherwise the best applicable
+ * account discount, and the account funds available for it. Nothing is applied, reserved or redeemed. An invalid
+ * or inapplicable code fails the request without changing the session.
+ *
+ * Complete the session with the returned `total` as `expected_amount`, the same `promotion_code` and, for an
+ * immediate change, the returned `proration_date`. An expired session is refused with
+ * `BILLING_CHECKOUT_SESSION_EXPIRED`, and a complete one with `BILLING_CHECKOUT_SESSION_COMPLETE`; read its order
+ * instead.
+ *
+ * Open to the owner of the session's billing account and to members of its project.
+ * @summary Quote a Checkout Session
+ */
+export declare const getCheckoutSessionQuote: (checkoutSessionId: string, params?: GetCheckoutSessionQuoteParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getCheckoutSessionQuoteResponse>;
+export type confirmCheckoutSessionResponse200 = {
+    data: CheckoutSessionResult;
+    status: 200;
+};
+export type confirmCheckoutSessionResponse409 = {
+    data: Error;
+    status: 409;
+};
+export type confirmCheckoutSessionResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200 | 409>;
+};
+export type confirmCheckoutSessionResponseSuccess = confirmCheckoutSessionResponse200 & {
+    headers: Headers;
+};
+export type confirmCheckoutSessionResponseError = (confirmCheckoutSessionResponse409 | confirmCheckoutSessionResponseDefault) & {
+    headers: Headers;
+};
+export type confirmCheckoutSessionResponse = confirmCheckoutSessionResponseSuccess | confirmCheckoutSessionResponseError;
+export declare const getConfirmCheckoutSessionUrl: (checkoutSessionId: string) => string;
+/**
+ * Completes an open session: applies `promotion_code`, or otherwise the best applicable account discount, checks
+ * the total against `expected_amount` and creates the order with its invoice issued. A zero-total invoice is paid
+ * at once; otherwise pay the invoice next. A failed payment leaves the order and its terms as they are, and the
+ * invoice can be paid again until the order expires. Nothing is created when the code is invalid or
+ * inapplicable or the total differs, which fails with `BILLING_AMOUNT_CHANGED`.
+ *
+ * Confirming a complete session again with the same terms returns it with its order; different terms are refused
+ * with `BILLING_CHECKOUT_SESSION_COMPLETE`. An expired session is refused with `BILLING_CHECKOUT_SESSION_EXPIRED`.
+ * The order is delivered by the service that owns it once paid; confirmation alone does not mean delivery.
+ *
+ * Open to the owner of the session's billing account and to members of its project.
+ * @summary Confirm a Checkout Session
+ */
+export declare const confirmCheckoutSession: (checkoutSessionId: string, checkoutSessionConfirm: CheckoutSessionConfirm, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<confirmCheckoutSessionResponse>;
+export type expireCheckoutSessionResponse200 = {
+    data: CheckoutSession;
+    status: 200;
+};
+export type expireCheckoutSessionResponse409 = {
+    data: Error;
+    status: 409;
+};
+export type expireCheckoutSessionResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200 | 409>;
+};
+export type expireCheckoutSessionResponseSuccess = expireCheckoutSessionResponse200 & {
+    headers: Headers;
+};
+export type expireCheckoutSessionResponseError = (expireCheckoutSessionResponse409 | expireCheckoutSessionResponseDefault) & {
+    headers: Headers;
+};
+export type expireCheckoutSessionResponse = expireCheckoutSessionResponseSuccess | expireCheckoutSessionResponseError;
+export declare const getExpireCheckoutSessionUrl: (checkoutSessionId: string) => string;
+/**
+ * Ends an open session without an order; the service that created it releases what it was holding for the purchase. An expired session is returned unchanged. Open to the owner of the session's billing account and to members of its project.
+ * @summary Expire a Checkout Session
+ */
+export declare const expireCheckoutSession: (checkoutSessionId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<expireCheckoutSessionResponse>;
+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;
+/**
+ * Orders of your billing accounts with their status and invoice amounts; members of a project list its orders with `project_ids`. A pending order is not yet accepted and can expire at expires_at; its invoice shows whether payment is needed. Accepted does not mean delivered.
+ * @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;
+/**
+ * An order of your billing account or of a project you are a member of, with its status and invoice. An unknown order returns 404; any other order returns 403.
+ * @summary Get order
+ */
+export declare const getOrder: (orderId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getOrderResponse>;
+export type previewOrderRefundResponse200 = {
+    data: OrderRefundPreview;
+    status: 200;
+};
+export type previewOrderRefundResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type previewOrderRefundResponseSuccess = previewOrderRefundResponse200 & {
+    headers: Headers;
+};
+export type previewOrderRefundResponseError = previewOrderRefundResponseDefault & {
+    headers: Headers;
+};
+export type previewOrderRefundResponse = previewOrderRefundResponseSuccess | previewOrderRefundResponseError;
+export declare const getPreviewOrderRefundUrl: (orderId: string, params?: PreviewOrderRefundParams) => string;
+/**
+ * What canceling the listed items, or the whole order, would refund to the original payment sources. Nothing is canceled or refunded. Open to the owner of the order's billing account and to members of its project.
+ * @summary Preview an order refund
+ */
+export declare const previewOrderRefund: (orderId: string, params?: PreviewOrderRefundParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<previewOrderRefundResponse>;
+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 undelivered items of an order that has not been accepted, without recording a delivery
+ * failure. Omit order_item_ids to select every pending item. Delivered items stay delivered and are not
+ * refunded; failed items keep their outcome. The order stays pending while any item is pending, and its final
+ * status follows its items.
+ *
+ * The canceled items keep their agreed amounts and discounts: credit notes reduce the issued invoice, and
+ * collected amounts return to their original payment sources, possibly asynchronously. An online
+ * payment waiting for the payer is canceled with the order; one the gateway is processing is refused with
+ * `BILLING_PAYMENT_PENDING` and `meta.transaction_id`. Repeating the cancellation does not refund twice.
+ *
+ * An accepted order is canceled by its owning service, and delivered items through subscription cancellation.
+ * Refunds are previewed with `preview-order-refund`. Open to the owner of the order's billing account and to members of its project.
+ * @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. Readable by whoever can read the order.
+ * @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 granted by live subscriptions and active feature grants; members of a project list its entitlements with `project_ids`. A capability not held is not listed, and one stops being listed when the subscription or grant providing it ends.
+ * @summary List entitlements
+ */
+export declare const listEntitlements: (params?: ListEntitlementsParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listEntitlementsResponse>;
+export type listFeatureGrantsResponse200 = {
+    data: FeatureGrantList;
+    status: 200;
+};
+export type listFeatureGrantsResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listFeatureGrantsResponseSuccess = listFeatureGrantsResponse200 & {
+    headers: Headers;
+};
+export type listFeatureGrantsResponseError = listFeatureGrantsResponseDefault & {
+    headers: Headers;
+};
+export type listFeatureGrantsResponse = listFeatureGrantsResponseSuccess | listFeatureGrantsResponseError;
+export declare const getListFeatureGrantsUrl: (params?: ListFeatureGrantsParams) => string;
+/**
+ * Features held by a billing account for a period, for example through a membership. While a grant is active, every project whose current billing account holds it has the feature, in addition to its subscriptions' features.
+ * @summary List feature grants
+ */
+export declare const listFeatureGrants: (params?: ListFeatureGrantsParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listFeatureGrantsResponse>;
+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 active price in the currency, one entry per plan and price. Archived prices are not listed; existing subscriptions keep the terms they were bought at.
+ * @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 searchPricesResponse200 = {
+    data: PriceList;
+    status: 200;
+};
+export type searchPricesResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type searchPricesResponseSuccess = searchPricesResponse200 & {
+    headers: Headers;
+};
+export type searchPricesResponseError = searchPricesResponseDefault & {
+    headers: Headers;
+};
+export type searchPricesResponse = searchPricesResponseSuccess | searchPricesResponseError;
+export declare const getSearchPricesUrl: () => string;
+/**
+ * Lists the active prices in `currency` that meet every condition in the body, as `list-prices` lists them, for
+ * anyone, signed in or not. Use it for conditions a query string cannot hold, such as the plans of a whole
+ * catalog page. A price that delegates to a rate card has no amount of its own; read its rates with
+ * `search-rates`.
+ * @summary Search what is on sale, with prices
+ */
+export declare const searchPrices: (priceSearch: PriceSearch, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<searchPricesResponse>;
+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;
+/**
+ * Registered products. If-None-Match returns 304 for an unchanged page.
+ * @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;
+/**
+ * A product by its ID.
+ * @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;
+/**
+ * A plan, including one no longer on sale.
+ * @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;
+/**
+ * A catalog price, archived prices included. The terms of past purchases are on their orders and subscriptions.
+ * @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;
+/**
+ * Active plans of product_id with their features. An unknown product returns 404; If-None-Match returns 304 for an unchanged page.
+ * @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. An account with a negotiated agreement may be charged less, never 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;
+/**
+ * Rules of a public rate card; contract cards are not readable here.
+ * @summary List catalog rates
+ */
+export declare const listRates: (rateCardId: string, params?: ListRatesParams, headers?: ListRatesHeaders, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listRatesResponse>;
+export type searchRatesResponse200 = {
+    data: RateList;
+    status: 200;
+};
+export type searchRatesResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type searchRatesResponseSuccess = searchRatesResponse200 & {
+    headers: Headers;
+};
+export type searchRatesResponseError = searchRatesResponseDefault & {
+    headers: Headers;
+};
+export type searchRatesResponse = searchRatesResponseSuccess | searchRatesResponseError;
+export declare const getSearchRatesUrl: (rateCardId: string) => string;
+/**
+ * Rules of a public rate card that meet every condition in the body, as `list-rates` lists them, for anyone,
+ * signed in or not; contract cards are not readable here. Use it to read the rates at the dimension values of the
+ * items on a page, such as each region and machine type offered, and match each rate to its price by meter,
+ * usage type, interval and dimensions.
+ * @summary Search catalog rates
+ */
+export declare const searchRates: (rateCardId: string, rateSearch: RateSearch, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<searchRatesResponse>;
+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;
+/**
+ * Continuous metering registrations paid for by your billing accounts; members of a project list its registrations with `project_ids`. Their state does not describe the resource's runtime.
+ * @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.
+ *
+ * Open to the owner of the account and to members with the project permission `billing:finance.manage` of each
+ * project in `project_ids`, which must then be given and currently assigned to the account.
+ * @summary List account spend
+ */
+export declare const listSpend: (params: ListSpendParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listSpendResponse>;
+export type listMonthlyStatementsResponse200 = {
+    data: MonthlyStatementList;
+    status: 200;
+};
+export type listMonthlyStatementsResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listMonthlyStatementsResponseSuccess = listMonthlyStatementsResponse200 & {
+    headers: Headers;
+};
+export type listMonthlyStatementsResponseError = listMonthlyStatementsResponseDefault & {
+    headers: Headers;
+};
+export type listMonthlyStatementsResponse = listMonthlyStatementsResponseSuccess | listMonthlyStatementsResponseError;
+export declare const getListMonthlyStatementsUrl: (params?: ListMonthlyStatementsParams) => string;
+/**
+ * Usage billing per UTC calendar month for your billing accounts, newest first. Each month combines its statements, the invoices they issued and how those were paid.
+ * @summary List monthly statements
+ */
+export declare const listMonthlyStatements: (params?: ListMonthlyStatementsParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listMonthlyStatementsResponse>;
+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;
+/**
+ * Statements of your billing accounts, filtered by billing_account_id, open or closed and period start. A closed statement does not mean the month is complete.
+ * @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;
+/**
+ * A statement of your billing account with its period, estimated or closed amounts and invoice. Returns 404 for a missing statement and 403 for another user's account.
+ * @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;
+/**
+ * The statement's consumption, grouped by project, product or meter and filtered within the statement. Quantities are given only for meter groups; grouping by meter also splits by the meter's presentation dimensions. Open to the owner of the statement's account and to members with the project permission `billing:finance.manage` of each project in `project_ids`, which must then be given and currently assigned to that account.
+ * @summary Get grouped consumption
+ */
+export declare const getStatementUsage: (statementId: string, params?: GetStatementUsageParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getStatementUsageResponse>;