@leaflow/sdk 0.107.0 → 0.109.0

package/dist/billing/v1/generated/functions.js

@@ -0,0 +1,1794 @@
+export const getListCurrenciesUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://billing.leaflow.cloud/api/v1/currencies?${stringifiedParams}`
+        : `https://billing.leaflow.cloud/api/v1/currencies`;
+};
+/**
+ * The currencies a new billing account can be opened in. A retired currency is not listed,
+ * although accounts already opened in it keep working. Results are paginated.
+ * @summary List currencies accounts can be opened in
+ */
+export const listCurrencies = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListCurrenciesUrl(params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListBillingAccountsUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://billing.leaflow.cloud/api/v1/billing-accounts?${stringifiedParams}`
+        : `https://billing.leaflow.cloud/api/v1/billing-accounts`;
+};
+/**
+ * @summary List billing accounts
+ */
+export const listBillingAccounts = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListBillingAccountsUrl(params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getCreateBillingAccountUrl = () => {
+    return `https://billing.leaflow.cloud/api/v1/billing-accounts`;
+};
+/**
+ * The currency is chosen here and cannot be changed afterwards. Everything charged to the
+ * account — prices, orders, invoices, balance — is denominated in it.
+ *
+ * One person may hold several accounts, for example a personal one and one for a team.
+ * @summary Create billing account
+ */
+export const createBillingAccount = async (billingAccountCreate, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getCreateBillingAccountUrl(), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(billingAccountCreate),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetBillingAccountUrl = (accountId) => {
+    return `https://billing.leaflow.cloud/api/v1/billing-accounts/${encodeURIComponent(String(accountId))}`;
+};
+/**
+ * @summary Get billing account
+ */
+export const getBillingAccount = async (accountId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetBillingAccountUrl(accountId), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getUpdateBillingAccountUrl = (accountId) => {
+    return `https://billing.leaflow.cloud/api/v1/billing-accounts/${encodeURIComponent(String(accountId))}`;
+};
+/**
+ * The legal name, address and tax identifier are copied onto each invoice when it is
+ * issued. Changing them here affects invoices issued afterwards, not those already sent.
+ *
+ * The currency cannot be changed.
+ * @summary Update billing account
+ */
+export const updateBillingAccount = async (accountId, billingAccountUpdate, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getUpdateBillingAccountUrl(accountId), {
+        ...options,
+        method: "PATCH",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(billingAccountUpdate),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetAccountBalanceUrl = (accountId) => {
+    return `https://billing.leaflow.cloud/api/v1/billing-accounts/${encodeURIComponent(String(accountId))}/balance`;
+};
+/**
+ * @summary Get account balance
+ */
+export const getAccountBalance = async (accountId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetAccountBalanceUrl(accountId), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetAccountMeteredUsageUrl = (accountId) => {
+    return `https://billing.leaflow.cloud/api/v1/billing-accounts/${encodeURIComponent(String(accountId))}/metered-usage`;
+};
+/**
+ * Whether the account has anything billed by usage, and what that usage has cost over the last
+ * seven days. Usage is paid from the balance, so this tells how much of the balance it is likely
+ * to need: the balance divided by `average_daily_amount` is roughly how many days it lasts.
+ * @summary Get account metered usage
+ */
+export const getAccountMeteredUsage = async (accountId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetAccountMeteredUsageUrl(accountId), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListPaymentOptionsUrl = (accountId, params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://billing.leaflow.cloud/api/v1/billing-accounts/${encodeURIComponent(String(accountId))}/payment-options?${stringifiedParams}`
+        : `https://billing.leaflow.cloud/api/v1/billing-accounts/${encodeURIComponent(String(accountId))}/payment-options`;
+};
+/**
+ * Lists the payment gateways and methods that currently accept payment in this account's currency, the
+ * preferred gateway first. Top-ups and invoice payments must name a gateway and method listed here;
+ * others are refused. An empty result means no online payment is available for this account.
+ * Results are paginated.
+ * @summary List payment options
+ */
+export const listPaymentOptions = async (accountId, params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListPaymentOptionsUrl(accountId, params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListProjectAssignmentsUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://billing.leaflow.cloud/api/v1/assignments?${stringifiedParams}`
+        : `https://billing.leaflow.cloud/api/v1/assignments`;
+};
+/**
+ * @summary List project assignments
+ */
+export const listProjectAssignments = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListProjectAssignmentsUrl(params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetProjectAssignmentUrl = (projectId) => {
+    return `https://billing.leaflow.cloud/api/v1/assignments/${encodeURIComponent(String(projectId))}`;
+};
+/**
+ * Returns the current assignment for the project identified by projectId. Returns 404 when
+ * no billing account is assigned; no resources can be created until one is assigned.
+ * @summary Get project assignment
+ */
+export const getProjectAssignment = async (projectId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetProjectAssignmentUrl(projectId), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getSetProjectAssignmentUrl = (projectId) => {
+    return `https://billing.leaflow.cloud/api/v1/assignments/${encodeURIComponent(String(projectId))}`;
+};
+/**
+ * Charges already incurred remain with the billing account that was linked when they
+ * occurred, and are still invoiced to it. Metered resources are settled up to the moment of
+ * the change. Amounts owed by the previous billing account remain owed by it and do not
+ * prevent the change.
+ *
+ * Orders keep the billing account they were placed with and are fulfilled as placed. Periods
+ * already paid for are unaffected; renewals are charged to the new billing account.
+ *
+ * The request is refused once the project no longer accepts purchases because it is being
+ * deleted, and while a subscription or an order in progress in the project uses a currency
+ * other than that of the new billing account.
+ * @summary Set project assignment
+ */
+export const setProjectAssignment = async (projectId, setProjectAssignmentRequest, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getSetProjectAssignmentUrl(projectId), {
+        ...options,
+        method: "PUT",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(setProjectAssignmentRequest),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getUnlinkProjectBillingAccountUrl = (projectId) => {
+    return `https://billing.leaflow.cloud/api/v1/assignments/${encodeURIComponent(String(projectId))}`;
+};
+/**
+ * Ends the project's current assignment without deleting its assignment history.
+ *
+ * Permitted only when nothing in the project is still running or in progress: no metered
+ * resources, no subscriptions that have not ended, and no orders in progress, including
+ * changes scheduled for the end of a period. Orders are not modified by this request; wait
+ * for them to complete, and have the service that scheduled a change call it off.
+ *
+ * Charges already incurred remain with the billing account and are invoiced to it as usual.
+ * Amounts the billing account owes do not prevent unlinking.
+ *
+ * After this the project cannot make purchases until a billing account is linked again.
+ * @summary Unlink project billing account
+ */
+export const unlinkProjectBillingAccount = async (projectId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getUnlinkProjectBillingAccountUrl(projectId), {
+        ...options,
+        method: "DELETE",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : undefined;
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListTopUpsUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://billing.leaflow.cloud/api/v1/top-ups?${stringifiedParams}`
+        : `https://billing.leaflow.cloud/api/v1/top-ups`;
+};
+/**
+ * Lists only the authenticated user's top-ups. Includes pending, failed and canceled attempts; no invoice is
+ * created for a top-up. Items carry no `action`; read a pending top-up with get-top-up to continue its payment.
+ * @summary List top ups
+ */
+export const listTopUps = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListTopUpsUrl(params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getCreateTopUpUrl = () => {
+    return `https://billing.leaflow.cloud/api/v1/top-ups`;
+};
+/**
+ * Creates a top-up for an account owned by the authenticated user and returns its payment information.
+ * The balance increases only after the payment gateway confirms receipt. A top-up has no invoice.
+ * Keep the supplied ID to query the original attempt after a lost response; duplicate creation conflicts.
+ * @summary Create top up
+ */
+export const createTopUp = async (topUpCreate, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getCreateTopUpUrl(), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(topUpCreate),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetTopUpUrl = (topUpId) => {
+    return `https://billing.leaflow.cloud/api/v1/top-ups/${encodeURIComponent(String(topUpId))}`;
+};
+/**
+ * Reads a top-up owned by the authenticated user, including its outcome and the part of it not yet spent.
+ * It is not an invoice.
+ *
+ * While the top-up is pending, the answer includes the customer's next step as the payment gateway
+ * currently reports it, so that a payment interrupted by a closed page can be continued. When the gateway
+ * cannot be reached, the top-up is returned without `action`; read it again later.
+ * @summary Get top up
+ */
+export const getTopUp = async (topUpId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetTopUpUrl(topUpId), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getCancelTopUpUrl = (topUpId) => {
+    return `https://billing.leaflow.cloud/api/v1/top-ups/${encodeURIComponent(String(topUpId))}/cancel`;
+};
+/**
+ * Withdraws a pending top-up owned by the authenticated user at the payment gateway. It becomes
+ * `canceled` with `cancellation_reason` `requested_by_customer`, and no money is collected for it. Canceling a
+ * top-up that is already canceled returns it unchanged.
+ *
+ * If the gateway has already collected the payment, nothing is withdrawn and the top-up is returned
+ * as `succeeded` with the balance increased. Check `status` in the answer rather than assuming the
+ * cancellation took effect.
+ *
+ * Fails with 409 and BILLING_TOPUP_NOT_CANCELABLE when the top-up has already succeeded or failed,
+ * with `status` naming that outcome, and while the gateway is processing the payment and can no
+ * longer withdraw it, with `status` set to `pending`; read the top-up again later in that case.
+ * @summary Cancel top up
+ */
+export const cancelTopUp = async (topUpId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getCancelTopUpUrl(topUpId), {
+        ...options,
+        method: "POST",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListPaymentMethodsUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://billing.leaflow.cloud/api/v1/payment-methods?${stringifiedParams}`
+        : `https://billing.leaflow.cloud/api/v1/payment-methods`;
+};
+/**
+ * @summary List payment methods
+ */
+export const listPaymentMethods = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListPaymentMethodsUrl(params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getCreatePaymentMethodSetupUrl = () => {
+    return `https://billing.leaflow.cloud/api/v1/payment-methods/setup`;
+};
+/**
+ * Returns what is needed to hand the browser over to the payment gateway's own card
+ * form. Nothing is charged, and the method appears in the list once the gateway
+ * confirms it.
+ *
+ * Card numbers are never sent to or stored by this service.
+ * @summary Create payment method setup
+ */
+export const createPaymentMethodSetup = async (paymentMethodSetup, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getCreatePaymentMethodSetupUrl(), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(paymentMethodSetup),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getSetDefaultPaymentMethodUrl = (paymentMethodId) => {
+    return `https://billing.leaflow.cloud/api/v1/payment-methods/${encodeURIComponent(String(paymentMethodId))}/default`;
+};
+/**
+ * @summary Set default payment method
+ */
+export const setDefaultPaymentMethod = async (paymentMethodId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getSetDefaultPaymentMethodUrl(paymentMethodId), {
+        ...options,
+        method: "PUT",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getDeletePaymentMethodUrl = (paymentMethodId) => {
+    return `https://billing.leaflow.cloud/api/v1/payment-methods/${encodeURIComponent(String(paymentMethodId))}`;
+};
+/**
+ * Refused when it is the only method on an account that has resources billed by the hour,
+ * as there would be nothing left to charge when the balance runs out.
+ * @summary Delete payment method
+ */
+export const deletePaymentMethod = async (paymentMethodId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDeletePaymentMethodUrl(paymentMethodId), {
+        ...options,
+        method: "DELETE",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : undefined;
+    return { data, status: res.status, headers: res.headers };
+};
+export const getPayInvoiceUrl = (invoiceId) => {
+    return `https://billing.leaflow.cloud/api/v1/invoices/${encodeURIComponent(String(invoiceId))}/pay`;
+};
+/**
+ * Applies eligible credit grants and available balance as requested, then collects the remainder
+ * through the selected payment gateway and method. With no gateway selection, insufficient
+ * account funds fail without starting an online payment. Card and non-card methods use this same
+ * operation. Promotion codes are confirmed by checkout, before collecting payment.
+ *
+ * Returns a payment action when customer interaction is required. requires_action and processing
+ * do not mean paid; the invoice is marked paid after payment is confirmed. An unresolved payment
+ * attempt is reused, and retries do not apply credit grants or balance twice.
+ *
+ * Calling this on an invoice that is already paid returns the existing payment result without
+ * another charge. A draft order invoice must first be confirmed through checkout. It and a void
+ * invoice are refused with `BILLING_INVOICE_NOT_PAYABLE`; the invoice of an order that has failed or was
+ * canceled, with `BILLING_ORDER_FAILED` or `BILLING_ORDER_CANCELED`; and that of an order whose
+ * payment deadline has passed, with `BILLING_ORDER_EXPIRED`.
+ * @summary Pay an invoice
+ */
+export const payInvoice = async (invoiceId, payInvoiceRequest, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getPayInvoiceUrl(invoiceId), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(payInvoiceRequest),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getPreviewInvoicePaymentUrl = (invoiceId, params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://billing.leaflow.cloud/api/v1/invoices/${encodeURIComponent(String(invoiceId))}/payment-preview?${stringifiedParams}`
+        : `https://billing.leaflow.cloud/api/v1/invoices/${encodeURIComponent(String(invoiceId))}/payment-preview`;
+};
+/**
+ * What paying this invoice now would take from credit grants, from the balance and, for the rest,
+ * from a payment gateway. It is computed as paying computes it, so paying with the same options
+ * straight afterwards takes exactly these amounts unless the account's funds change in between.
+ * Nothing is charged, reserved or created.
+ *
+ * Refused with the same errors as paying, except that insufficient funds are not an error here:
+ * they show as a `gateway_amount` above zero.
+ * @summary Preview invoice payment
+ */
+export const previewInvoicePayment = async (invoiceId, params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getPreviewInvoicePaymentUrl(invoiceId, params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getPayTogetherUrl = () => {
+    return `https://billing.leaflow.cloud/api/v1/payments`;
+};
+/**
+ * Pays outstanding invoices, including the invoices of the listed orders, from the account's
+ * eligible credit grants and then its balance. No payment gateway is used; an invoice to be
+ * paid online is paid on its own.
+ *
+ * Either every invoice is paid or none is. When the credit grants and balance cannot cover
+ * them all, the request fails with `BILLING_INSUFFICIENT_FUNDS` and nothing is charged.
+ * Invoices that are already paid are not charged again. An invoice with an online payment
+ * still in progress is refused with `BILLING_PAYMENT_PENDING`, a draft order invoice or void invoice with
+ * `BILLING_INVOICE_NOT_PAYABLE`, an order that has failed or was canceled with
+ * `BILLING_ORDER_FAILED` or `BILLING_ORDER_CANCELED`, and an order whose payment deadline has
+ * passed with `BILLING_ORDER_EXPIRED`.
+ * @summary Pay together
+ */
+export const payTogether = async (payTogetherRequest, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getPayTogetherUrl(), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(payTogetherRequest),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getPreviewPayTogetherUrl = () => {
+    return `https://billing.leaflow.cloud/api/v1/payments/preview`;
+};
+/**
+ * What paying these invoices together now would take from credit grants and from the balance,
+ * invoice by invoice in the order they would be paid. It is computed as paying together computes
+ * it. Nothing is charged, reserved or created.
+ *
+ * Refused with the same errors as paying together, except that insufficient funds are not an
+ * error here: they show as a `gateway_amount` above zero, and paying together would then be
+ * refused with `BILLING_INSUFFICIENT_FUNDS`.
+ * @summary Preview paying together
+ */
+export const previewPayTogether = async (payTogetherRequest, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getPreviewPayTogetherUrl(), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(payTogetherRequest),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListInvoicesUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://billing.leaflow.cloud/api/v1/invoices?${stringifiedParams}`
+        : `https://billing.leaflow.cloud/api/v1/invoices`;
+};
+/**
+ * @summary List invoices
+ */
+export const listInvoices = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListInvoicesUrl(params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetInvoiceUrl = (invoiceId) => {
+    return `https://billing.leaflow.cloud/api/v1/invoices/${encodeURIComponent(String(invoiceId))}`;
+};
+/**
+ * @summary Get invoice
+ */
+export const getInvoice = async (invoiceId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetInvoiceUrl(invoiceId), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListInvoiceItemsUrl = (invoiceId, params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://billing.leaflow.cloud/api/v1/invoices/${encodeURIComponent(String(invoiceId))}/items?${stringifiedParams}`
+        : `https://billing.leaflow.cloud/api/v1/invoices/${encodeURIComponent(String(invoiceId))}/items`;
+};
+/**
+ * @summary List invoice items
+ */
+export const listInvoiceItems = async (invoiceId, params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListInvoiceItemsUrl(invoiceId, params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListTransactionsUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://billing.leaflow.cloud/api/v1/transactions?${stringifiedParams}`
+        : `https://billing.leaflow.cloud/api/v1/transactions`;
+};
+/**
+ * @summary List transactions
+ */
+export const listTransactions = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListTransactionsUrl(params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListAccountDiscountsUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://billing.leaflow.cloud/api/v1/discounts?${stringifiedParams}`
+        : `https://billing.leaflow.cloud/api/v1/discounts`;
+};
+/**
+ * Coupons placed on the account directly, which apply at checkout without a code being
+ * entered. A coupon reached through a code is not listed here.
+ * @summary List the coupons held on this account
+ */
+export const listAccountDiscounts = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListAccountDiscountsUrl(params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListCreditGrantsUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://billing.leaflow.cloud/api/v1/credit-grants?${stringifiedParams}`
+        : `https://billing.leaflow.cloud/api/v1/credit-grants`;
+};
+/**
+ * Each grant shows what remains and what it may be used for. Credit is spent before the balance
+ * and cannot be withdrawn.
+ * @summary List credit grants
+ */
+export const listCreditGrants = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListCreditGrantsUrl(params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListRefundsUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://billing.leaflow.cloud/api/v1/refunds?${stringifiedParams}`
+        : `https://billing.leaflow.cloud/api/v1/refunds`;
+};
+/**
+ * Newest first.
+ * @summary List refunds
+ */
+export const listRefunds = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListRefundsUrl(params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListUsageChargesUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://billing.leaflow.cloud/api/v1/usage-charges?${stringifiedParams}`
+        : `https://billing.leaflow.cloud/api/v1/usage-charges`;
+};
+/**
+ * Each charge is added to the month's usage invoice as it is priced, summed into one line per
+ * subscription, project, resource, meter and rate. Filter by `invoice_item_id` to see the
+ * charges behind a line. Charges still waiting to be priced are included too.
+ *
+ * Only charges recorded against your billing accounts are included, before filtering, counting and pagination. Reassigning a project does not move previously recorded charges to its new account.
+ * @summary List usage charges
+ */
+export const listUsageCharges = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListUsageChargesUrl(params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListSubscriptionsUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://billing.leaflow.cloud/api/v1/subscriptions?${stringifiedParams}`
+        : `https://billing.leaflow.cloud/api/v1/subscriptions`;
+};
+/**
+ * @summary List subscriptions
+ */
+export const listSubscriptions = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListSubscriptionsUrl(params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetSubscriptionUrl = (subscriptionId) => {
+    return `https://billing.leaflow.cloud/api/v1/subscriptions/${encodeURIComponent(String(subscriptionId))}`;
+};
+/**
+ * @summary Get subscription
+ */
+export const getSubscription = async (subscriptionId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetSubscriptionUrl(subscriptionId), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getCreateQuoteUrl = () => {
+    return `https://billing.leaflow.cloud/api/v1/quotes`;
+};
+/**
+ * Calculates exactly one target for a billing account you own: proposed items, existing order checkout, renewals, cancellation or order refund. Returns all requested calculations or a structured error. No quote is saved and no resource, payment, reservation or redemption is created.
+ *
+ * Existing orders use their recorded purchase account and terms. Renewals and cancellations use the account currently paying for each subscription. Every target must belong to the requested account. A project association or project token does not authorize a quote.
+ *
+ * Use an existing order quote's total as expected_amount at checkout. A confirmed order returns its recorded amounts; a different promotion code is refused. Requested future usage estimates are not collectible checkout amounts. An unknown delivery outcome is not proof of refund eligibility.
+ * @summary Create a quote
+ */
+export const createQuote = async (quoteRequest, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getCreateQuoteUrl(), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(quoteRequest),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListCancellationsUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://billing.leaflow.cloud/api/v1/cancellations?${stringifiedParams}`
+        : `https://billing.leaflow.cloud/api/v1/cancellations`;
+};
+/**
+ * Newest first. Filter by `subscription_id` and `status=open` to find the cancellation now under way for a subscription.
+ * @summary List cancellations
+ */
+export const listCancellations = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListCancellationsUrl(params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getCreateCancellationUrl = () => {
+    return `https://billing.leaflow.cloud/api/v1/cancellations`;
+};
+/**
+ * Ends a set of subscriptions of one service together, at one time. Deleting a resource that a
+ * subscription pays for is an `immediate` cancellation of every subscription released with it,
+ * such as a server with the disks deleted along with it, or an address with its bandwidth.
+ *
+ * The service that provides the resources releases them: at once for `immediate`, or at
+ * `scheduled_at`, the end of the paid term, for `period_end`. When release is confirmed, the
+ * unused value is returned the way it was paid, under the refund terms agreed when each
+ * subscription was bought. For `immediate` the refund is computed as of `proration_date`, so the
+ * amount confirmed here is the amount returned: prepaid service used while the resources are
+ * being released is not deducted from it. Usage of a postpaid subscription is charged until its
+ * resources are released, as usual.
+ *
+ * `mode` must be allowed for every subscription. Postpaid and one-time subscriptions end only
+ * `immediate`. A prepaid subscription ends `period_end` while its paid term lasts, and
+ * `immediate` unless its termination terms allow only the end of the paid term and that term has
+ * not ended yet. For `period_end` the paid terms of all the subscriptions must end at the same
+ * time.
+ *
+ * Refused with:
+ * - 400 `BILLING_CANCELLATION_INVALID` when `subscription_ids` or `proration_date` is not
+ *   acceptable (`meta.field`), or the subscriptions do not all belong to one service, project,
+ *   account and currency;
+ * - 409 `BILLING_CANCELLATION_CONFLICT` when a subscription has not started or has ended;
+ * - 422 `BILLING_CANCELLATION_MODE_FIXED` when `mode` is not allowed for a subscription, and
+ *   `BILLING_CANCELLATION_TERMS_UNSET` when a prepaid subscription has no termination terms;
+ *   both carry `meta.subscription_id`;
+ * - 409 `BILLING_CANCELLATION_SCHEDULES_DIFFER` when, for `period_end`, the paid terms end at
+ *   different times;
+ * - 409 `BILLING_SUBSCRIPTION_OPERATION_PENDING` when a subscription is already being canceled
+ *   (`meta.cancellation_id`) or reclaimed (`meta.action_id`);
+ * - 409 `BILLING_ORDER_PAYMENT_IN_FLIGHT` while an online payment for a renewal of one of them
+ *   is in progress;
+ * - 409 `BILLING_CANCELLATION_REFUND_CHANGED` when the refund is no longer
+ *   `expected_refundable_amount`; quote again.
+ *
+ * Sending the same request again, for the same subscriptions, mode and amount while that
+ * cancellation is still open, returns it with 200 rather than creating another. Renewal orders
+ * still waiting for payment are canceled along with it, and automatic renewal is turned off for
+ * every subscription in the set, for `period_end` as well as `immediate`.
+ * @summary Cancel subscriptions
+ */
+export const createCancellation = async (cancellationCreate, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getCreateCancellationUrl(), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(cancellationCreate),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetCancellationUrl = (cancellationId) => {
+    return `https://billing.leaflow.cloud/api/v1/cancellations/${encodeURIComponent(String(cancellationId))}`;
+};
+/**
+ * @summary Get a cancellation
+ */
+export const getCancellation = async (cancellationId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetCancellationUrl(cancellationId), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getWithdrawCancellationUrl = (cancellationId) => {
+    return `https://billing.leaflow.cloud/api/v1/cancellations/${encodeURIComponent(String(cancellationId))}/withdraw`;
+};
+/**
+ * Withdraws the whole cancellation while none of its resources has begun to be released; the
+ * subscriptions continue as before, except that automatic renewal, turned off when the
+ * cancellation was created, stays off until it is turned on again. After that it is refused with
+ * 409 `BILLING_CANCELLATION_CONFLICT`. Withdrawing one that is already withdrawn returns it
+ * unchanged.
+ * @summary Withdraw a cancellation
+ */
+export const withdrawCancellation = async (cancellationId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getWithdrawCancellationUrl(cancellationId), {
+        ...options,
+        method: "POST",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListRenewalPricesUrl = (subscriptionId, params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://billing.leaflow.cloud/api/v1/subscriptions/${encodeURIComponent(String(subscriptionId))}/renewal-prices?${stringifiedParams}`
+        : `https://billing.leaflow.cloud/api/v1/subscriptions/${encodeURIComponent(String(subscriptionId))}/renewal-prices`;
+};
+/**
+ * Lists the current renewal agreement and available intervals. The current option preserves recurring_amount; other options use current prices. Amounts cover the whole subscription quantity and exclude tax.
+ * @summary List the terms this item can be renewed for
+ */
+export const listRenewalPrices = async (subscriptionId, params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListRenewalPricesUrl(subscriptionId, params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getRenewSubscriptionUrl = (subscriptionId) => {
+    return `https://billing.leaflow.cloud/api/v1/subscriptions/${encodeURIComponent(String(subscriptionId))}/renew`;
+};
+/**
+ * Purchases prepaid periods from paid_until using the agreed recurring amount, and pays for them at
+ * once. A changed interval selects a current price and freezes new terms on the order, applied
+ * only after fulfillment. Existing paid periods keep their value.
+ *
+ * Without `payment_method_id`, the renewal is paid from credit grants and the balance as
+ * `use_credits` and `use_balance` allow; when they cannot pay it all, the renewal is refused with
+ * `BILLING_INSUFFICIENT_FUNDS` and no order is left. To pay another way, create a renewal order
+ * and pay its invoice instead.
+ *
+ * Save order_id before submitting and query the order after an unknown outcome; duplicate
+ * creation conflicts.
+ * @summary Renew subscription
+ */
+export const renewSubscription = async (subscriptionId, renewRequest, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getRenewSubscriptionUrl(subscriptionId), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(renewRequest),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getCreateRenewalOrderUrl = (subscriptionId) => {
+    return `https://billing.leaflow.cloud/api/v1/subscriptions/${encodeURIComponent(String(subscriptionId))}/renewal-orders`;
+};
+/**
+ * Places a renewal order with a draft invoice, without applying a new discount or charging anything.
+ * Quote and confirm its checkout before collecting payment to renew. Existing subscription
+ * discount commitments are retained. The periods and price are chosen as for renewing. The order
+ * can be paid until the current paid period ends, and never after the end of the first period it renews; unpaid by
+ * then, it is canceled. While auto-renew is on, the renewal due at the end of the period pays
+ * this order instead of placing another, confirming checkout with an applicable account discount
+ * first if it has not already been confirmed.
+ *
+ * Save `order_id` before submitting and read the order after an unknown outcome; creating it a
+ * second time conflicts.
+ * @summary Create renewal order
+ */
+export const createRenewalOrder = async (subscriptionId, renewalOrderRequest, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getCreateRenewalOrderUrl(subscriptionId), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(renewalOrderRequest),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getSetAutoRenewUrl = (subscriptionId) => {
+    return `https://billing.leaflow.cloud/api/v1/subscriptions/${encodeURIComponent(String(subscriptionId))}/auto-renew`;
+};
+/**
+ * Controls automatic prepaid renewal. Disabling it does not shorten paid_until and still permits
+ * manual renewal. Postpaid subscriptions do not renew and keep this false.
+ *
+ * While the subscription has an open cancellation, turning it on or off is refused with 409
+ * `BILLING_SUBSCRIPTION_OPERATION_PENDING` and `meta.cancellation_id`: creating the cancellation
+ * turned it off, and withdrawing the cancellation does not turn it back on.
+ * @summary Set auto renew
+ */
+export const setAutoRenew = async (subscriptionId, autoRenewSet, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getSetAutoRenewUrl(subscriptionId), {
+        ...options,
+        method: "PUT",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(autoRenewSet),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListAllowancesUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://billing.leaflow.cloud/api/v1/allowances?${stringifiedParams}`
+        : `https://billing.leaflow.cloud/api/v1/allowances`;
+};
+/**
+ * Lists remaining usage quantities, such as bytes, seconds or tokens. Applicable allowances are
+ * consumed before usage is charged. Lower priority values are consumed first, followed by earlier
+ * expiry and earlier issuance.
+ *
+ * Unused quantity expires without a refund or carry-over. Promotional allowances apply to usage paid
+ * by their holding account. Included allowances apply only to the associated subscription, including
+ * after its project moves to another billing account.
+ * @summary List allowances
+ */
+export const listAllowances = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListAllowancesUrl(params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListOrdersUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://billing.leaflow.cloud/api/v1/orders?${stringifiedParams}`
+        : `https://billing.leaflow.cloud/api/v1/orders`;
+};
+/**
+ * Lists acceptance status and associated invoice amounts. pending_checkout awaits confirmation;
+ * pending has confirmed checkout and may be unpaid or paid. active means accepted, not delivered.
+ * pending_checkout and pending orders can expire at expires_at.
+ * @summary List orders
+ */
+export const listOrders = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListOrdersUrl(params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetOrderUrl = (orderId) => {
+    return `https://billing.leaflow.cloud/api/v1/orders/${encodeURIComponent(String(orderId))}`;
+};
+/**
+ * @summary Get order
+ */
+export const getOrder = async (orderId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetOrderUrl(orderId), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getCheckoutOrderUrl = (orderId) => {
+    return `https://billing.leaflow.cloud/api/v1/orders/${encodeURIComponent(String(orderId))}/checkout`;
+};
+/**
+ * Confirms the purchase's final amount and discount. Supply the same promotion_code used for the
+ * preview, or omit it to select an applicable account discount. At most one new coupon is applied
+ * to an order; existing subscription discount commitments are not stacked with a new coupon on
+ * the same line. Promotion codes are evaluated against the order, not client-supplied line amounts.
+ *
+ * Rechecks eligibility and redemption availability. A different total fails with
+ * BILLING_AMOUNT_CHANGED. An invalid or inapplicable code fails rather than collecting full price.
+ * A failed confirmation leaves the invoice draft and reserves no discount redemption.
+ *
+ * A successful confirmation records the discount, including any recurring discount terms,
+ * reserves its redemption, moves pending_checkout to pending and finalizes the invoice when one
+ * is required. The reservation counts toward the code's limits and is consumed when the invoice
+ * is paid, or at confirmation when nothing is due. Use pay-invoice to collect
+ * its outstanding amount from account funds or a payment gateway. No payment attempt or checkout
+ * session is created by this operation. An order whose total is zero completes checkout at
+ * placement in either mode and does not need this operation; an order with an amount due, even
+ * when credits would cover it, still does. Checkout alone does not confirm resource delivery.
+ *
+ * Retrying with the same code and expected amount returns the existing order without another
+ * redemption. Omitting the code on a confirmed checkout retains its recorded discount. Changing
+ * that code is refused with BILLING_ORDER_CHECKOUT_CONFLICT. Payment retries reuse the confirmed
+ * terms. Cancellation, expiry or complete fulfillment failure releases the reservation or returns
+ * the consumed redemption; a refund alone does not.
+ *
+ * The order must belong to one of your billing accounts. A canceled, failed or expired order
+ * cannot be checked out. A period-end change cannot be checked out before its renewal invoice is
+ * available. Orders retain their billing account and currency after a project is linked elsewhere;
+ * discounts from another account cannot be used for them.
+ * @summary Confirm order checkout
+ */
+export const checkoutOrder = async (orderId, checkoutOrderRequest, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getCheckoutOrderUrl(orderId), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(checkoutOrderRequest),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getCancelOrderUrl = (orderId) => {
+    return `https://billing.leaflow.cloud/api/v1/orders/${encodeURIComponent(String(orderId))}/cancel`;
+};
+/**
+ * Withdraws an unaccepted order without recording a delivery failure. Payment may be absent,
+ * partial or complete; the order becomes canceled and any collected amount is automatically
+ * returned to its original payment sources. External payment-method refunds can finish
+ * asynchronously. Canceling an already canceled order returns it unchanged. A previously failed
+ * order keeps its failure outcome. The order and financial history are retained.
+ *
+ * Refused once the order is accepted: its owning service must coordinate cancellation during
+ * provisioning and confirm non-delivery and necessary cleanup before recording cancellation.
+ * Delivered items are ended through subscription cancellation. An unknown or in-flight payment
+ * outcome must first be reconciled; it is not assumed to be unpaid. Scheduled changes continue
+ * to be canceled through the service that owns them. Refund quotations use CreateQuote.refund.
+ * @summary Cancel order
+ */
+export const cancelOrder = async (orderId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getCancelOrderUrl(orderId), {
+        ...options,
+        method: "POST",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListOrderItemsUrl = (orderId, params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://billing.leaflow.cloud/api/v1/orders/${encodeURIComponent(String(orderId))}/items?${stringifiedParams}`
+        : `https://billing.leaflow.cloud/api/v1/orders/${encodeURIComponent(String(orderId))}/items`;
+};
+/**
+ * One entry per item bought, with the price charged and the period it covers.
+ * @summary List order items
+ */
+export const listOrderItems = async (orderId, params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListOrderItemsUrl(orderId, params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListEntitlementsUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://billing.leaflow.cloud/api/v1/entitlements?${stringifiedParams}`
+        : `https://billing.leaflow.cloud/api/v1/entitlements`;
+};
+/**
+ * Capabilities that come with what has been bought. A capability that is not held simply
+ * does not appear, so that "this does not exist" and "this has not been bought" cannot be
+ * confused.
+ *
+ * Derived from live subscriptions rather than stored, so this always agrees with what is
+ * being paid for. It stops being listed as soon as the subscription providing it ends.
+ * @summary List entitlements
+ */
+export const listEntitlements = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListEntitlementsUrl(params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListPricesUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://billing.leaflow.cloud/api/v1/prices?${stringifiedParams}`
+        : `https://billing.leaflow.cloud/api/v1/prices`;
+};
+/**
+ * Every sellable thing and what it costs, in one request. A plan appears once per price.
+ *
+ * `currency` is required: a plan has a price in each currency it is sold in, so "what does
+ * this cost" has no answer without one.
+ *
+ * Archived prices are left out. Existing subscriptions keep the terms they were bought at, so
+ * this is not the place to look up what an existing purchase is paying.
+ * @summary List what is on sale, with prices
+ */
+export const listPrices = async (params, headers, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getListPricesUrl(params), {
+        ...options,
+        method: "GET",
+        headers: { ...headers, ...getHeaders(options?.headers) },
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListProductsUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://billing.leaflow.cloud/api/v1/products?${stringifiedParams}`
+        : `https://billing.leaflow.cloud/api/v1/products`;
+};
+/**
+ * @summary List catalog products
+ */
+export const listProducts = async (params, headers, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getListProductsUrl(params), {
+        ...options,
+        method: "GET",
+        headers: { ...headers, ...getHeaders(options?.headers) },
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetProductUrl = (productId) => {
+    return `https://billing.leaflow.cloud/api/v1/products/${encodeURIComponent(String(productId))}`;
+};
+/**
+ * Resolves an identifier that was stored elsewhere — on an order line, an invoice line, or
+ * the terms of a credit — into something that can be displayed.
+ * @summary Get a service
+ */
+export const getProduct = async (productId, headers, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getGetProductUrl(productId), {
+        ...options,
+        method: "GET",
+        headers: { ...headers, ...getHeaders(options?.headers) },
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetPlanUrl = (planId) => {
+    return `https://billing.leaflow.cloud/api/v1/plans/${encodeURIComponent(String(planId))}`;
+};
+/**
+ * Resolves a stored identifier into something that can be displayed. Returns items that are
+ * no longer on sale: an existing purchase still refers to one.
+ * @summary Get a sellable item
+ */
+export const getPlan = async (planId, headers, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getGetPlanUrl(planId), {
+        ...options,
+        method: "GET",
+        headers: { ...headers, ...getHeaders(options?.headers) },
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetPriceUrl = (priceId) => {
+    return `https://billing.leaflow.cloud/api/v1/prices/${encodeURIComponent(String(priceId))}`;
+};
+/**
+ * Returns the catalog price, including archived prices. Fixed purchase history and renewal agreements are shown on orders and subscriptions rather than reconstructed from today's catalog.
+ * @summary Get a price
+ */
+export const getPrice = async (priceId, headers, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getGetPriceUrl(priceId), {
+        ...options,
+        method: "GET",
+        headers: { ...headers, ...getHeaders(options?.headers) },
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListPlansUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://billing.leaflow.cloud/api/v1/plans?${stringifiedParams}`
+        : `https://billing.leaflow.cloud/api/v1/plans`;
+};
+/**
+ * @summary List catalog plans
+ */
+export const listPlans = async (params, headers, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getListPlansUrl(params), {
+        ...options,
+        method: "GET",
+        headers: { ...headers, ...getHeaders(options?.headers) },
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListPricesByPlanUrl = (planId, params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://billing.leaflow.cloud/api/v1/plans/${encodeURIComponent(String(planId))}/prices?${stringifiedParams}`
+        : `https://billing.leaflow.cloud/api/v1/plans/${encodeURIComponent(String(planId))}/prices`;
+};
+/**
+ * Public list prices only. An account holding a negotiated agreement may be charged less;
+ * it is never charged more.
+ * @summary List catalog prices
+ */
+export const listPricesByPlan = async (planId, params, headers, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getListPricesByPlanUrl(planId, params), {
+        ...options,
+        method: "GET",
+        headers: { ...headers, ...getHeaders(options?.headers) },
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListRatesUrl = (rateCardId, params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://billing.leaflow.cloud/api/v1/rate-cards/${encodeURIComponent(String(rateCardId))}/rules?${stringifiedParams}`
+        : `https://billing.leaflow.cloud/api/v1/rate-cards/${encodeURIComponent(String(rateCardId))}/rules`;
+};
+/**
+ * Only public price lists are readable here. A list written for a single agreement is not,
+ * and its identifier cannot be used to reach it.
+ * @summary List catalog rates
+ */
+export const listRates = async (rateCardId, params, headers, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getListRatesUrl(rateCardId, params), {
+        ...options,
+        method: "GET",
+        headers: { ...headers, ...getHeaders(options?.headers) },
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListActiveResourcesUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://billing.leaflow.cloud/api/v1/active-resources?${stringifiedParams}`
+        : `https://billing.leaflow.cloud/api/v1/active-resources`;
+};
+/**
+ * Lists continuous metering registrations paid for by your billing accounts. Their state does not
+ * describe machine runtime or health. Project filters narrow the authorized accounts; they do not
+ * grant project-based access.
+ * @summary List active resources
+ */
+export const listActiveResources = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListActiveResourcesUrl(params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListSpendUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://billing.leaflow.cloud/api/v1/spend?${stringifiedParams}`
+        : `https://billing.leaflow.cloud/api/v1/spend`;
+};
+/**
+ * Aggregates rated and invoiced usage charges in the specified time range for one billing account.
+ * Includes usage not yet invoiced. Project filters use the account recorded on each charge, including
+ * charges for projects later assigned to another account. The total covers all matching groups, not
+ * just the returned page.
+ * @summary List account spend
+ */
+export const listSpend = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListSpendUrl(params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};