@leaflow/sdk 0.0.0-dev.35.g30ba751 → 0.0.0-dev.352.g85966ed

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

@@ -0,0 +1,2303 @@
+export const getListWithdrawalItemsUrl = (withdrawalId, 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/withdrawals/${encodeURIComponent(String(withdrawalId))}/items?${stringifiedParams}`
+        : `https://billing.leaflow.cloud/api/v1/withdrawals/${encodeURIComponent(String(withdrawalId))}/items`;
+};
+/**
+ * Paginated fixed source allocations and their outcomes. A failed source does not undo refunds already completed through other sources.
+ * @summary List withdrawal items
+ */
+export const listWithdrawalItems = async (withdrawalId, params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListWithdrawalItemsUrl(withdrawalId, 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 getListWithdrawalsUrl = (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/withdrawals?${stringifiedParams}`
+        : `https://billing.leaflow.cloud/api/v1/withdrawals`;
+};
+/**
+ * Paginated account withdrawal history, newest first. Account authorization applies to every record.
+ * @summary List withdrawals
+ */
+export const listWithdrawals = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListWithdrawalsUrl(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 getCreateWithdrawalUrl = () => {
+    return `https://billing.leaflow.cloud/api/v1/withdrawals`;
+};
+/**
+ * Withdraws the requested account balance through the original top-ups in receipt order. Fees are calculated independently per source. expected_items and expected_refund_amount must match the accepted preview. Reusing the same ID with different terms fails. Only successful items collect a fee.
+ * @summary Create withdrawal
+ */
+export const createWithdrawal = async (withdrawalCreate, 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)(getCreateWithdrawalUrl(), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(withdrawalCreate),
+    });
+    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 getPreviewWithdrawalUrl = () => {
+    return `https://billing.leaflow.cloud/api/v1/withdrawals/preview`;
+};
+/**
+ * Previews the available balance deduction, fees and exact refund allocation by original source. Omit amount to preview all available principal. Creates no withdrawal and reserves no funds. Fails if a selected source has no configured refund route or its original processing cost is not yet available.
+ * @summary Preview withdrawal
+ */
+export const previewWithdrawal = async (withdrawalPreviewRequest, 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)(getPreviewWithdrawalUrl(), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(withdrawalPreviewRequest),
+    });
+    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 getGetWithdrawalUrl = (withdrawalId) => {
+    return `https://billing.leaflow.cloud/api/v1/withdrawals/${encodeURIComponent(String(withdrawalId))}`;
+};
+/**
+ * Reads the accepted amounts and aggregate outcome of an authorized withdrawal. List its source items for each original-method refund result.
+ * @summary Get withdrawal
+ */
+export const getWithdrawal = async (withdrawalId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetWithdrawalUrl(withdrawalId), {
+        ...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 getListContactsUrl = (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))}/contacts?${stringifiedParams}`
+        : `https://billing.leaflow.cloud/api/v1/billing-accounts/${encodeURIComponent(String(accountId))}/contacts`;
+};
+/**
+ * Paginated contact profiles belonging to the billing account in the path, including inactive contacts. Returns 404 if the account does not exist.
+ * @summary List contacts
+ */
+export const listContacts = async (accountId, params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListContactsUrl(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 getCreateContactUrl = (accountId) => {
+    return `https://billing.leaflow.cloud/api/v1/billing-accounts/${encodeURIComponent(String(accountId))}/contacts`;
+};
+/**
+ * Creates a contact profile for the billing account in the path. Creating a contact does not select it for invoicing; set the account invoice_contact_id separately.
+ * @summary Create contact
+ */
+export const createContact = async (accountId, contactCreate, 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)(getCreateContactUrl(accountId), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(contactCreate),
+    });
+    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 getGetContactUrl = (accountId, contactId) => {
+    return `https://billing.leaflow.cloud/api/v1/billing-accounts/${encodeURIComponent(String(accountId))}/contacts/${encodeURIComponent(String(contactId))}`;
+};
+/**
+ * Returns a contact belonging to this billing account. Returns 404 if the contact does not exist in this account.
+ * @summary Get contact
+ */
+export const getContact = async (accountId, contactId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetContactUrl(accountId, contactId), {
+        ...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 getUpdateContactUrl = (accountId, contactId) => {
+    return `https://billing.leaflow.cloud/api/v1/billing-accounts/${encodeURIComponent(String(accountId))}/contacts/${encodeURIComponent(String(contactId))}`;
+};
+/**
+ * Updates a contact belonging to this billing account. Returns 404 if the contact does not exist in this account.
+ * @summary Update contact
+ */
+export const updateContact = async (accountId, contactId, contactUpdate, 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)(getUpdateContactUrl(accountId, contactId), {
+        ...options,
+        method: "PATCH",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(contactUpdate),
+    });
+    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 getDeleteContactUrl = (accountId, contactId) => {
+    return `https://billing.leaflow.cloud/api/v1/billing-accounts/${encodeURIComponent(String(accountId))}/contacts/${encodeURIComponent(String(contactId))}`;
+};
+/**
+ * Deletes a contact belonging to this billing account. Returns 404 if the contact does not exist in this account. The selected invoice contact must be cleared or replaced before deletion. Issued invoice snapshots are retained.
+ * @summary Delete contact
+ */
+export const deleteContact = async (accountId, contactId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDeleteContactUrl(accountId, contactId), {
+        ...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 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`;
+};
+/**
+ * Paginated billing accounts owned by the authenticated user. Accounts owned by other users are excluded; the result is empty when the user owns none.
+ * @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))}`;
+};
+/**
+ * Returns an owned account settlement currency, lifecycle state and selected invoice contact. Returns 404 if the account does not exist and 403 if it belongs to another user.
+ * @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))}`;
+};
+/**
+ * Select an active contact belonging to this account for future invoices. Its legal name,
+ * address and tax identifier are copied when an invoice is issued; issued snapshots are
+ * retained. Set invoice_contact_id to null to clear the selection. The currency cannot change.
+ * @summary Update billing account
+ */
+export 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`;
+};
+/**
+ * Returns the owned account balance, applicable credit groups, unpaid invoice amounts, unbilled estimates and pending returns separately. Returns 404 for a missing account and 403 for an account owned by another user.
+ * @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 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`;
+};
+/**
+ * Paginated current project assignments to accounts owned by the authenticated user. Filter by billing_account_id or project_ids; historical financial records keep their original account assignment.
+ * @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`;
+};
+/**
+ * Paginated saved payment methods for owned billing accounts, optionally restricted to billing_account_id. Removed methods are excluded; they do not disappear from historical payment records.
+ * @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`;
+};
+/**
+ * Selects an active saved payment method as the default for its owned billing account and returns it. Expired or removed methods cannot be selected; selecting the current default is idempotent.
+ * @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.
+ *
+ * The draft invoice of a deferred order is priced when it is first paid: Billing applies
+ * promotion_code, or the best applicable account discount when it is omitted, compares the total
+ * with expected_amount, records the discount on the order and issues the invoice before collecting.
+ * An invalid or inapplicable code fails rather than collecting full price, and a different total
+ * fails with `BILLING_AMOUNT_CHANGED`; in both cases nothing changes. The terms are fixed before
+ * any funds are collected and stay fixed when collection does not complete, for example with
+ * insufficient funds or a declined card: later attempts reuse them, and a different promotion_code
+ * is then refused with `BILLING_ORDER_CHECKOUT_CONFLICT`. A deferred period-end change can be paid
+ * once its first period is due to be invoiced; earlier attempts are refused with
+ * `BILLING_CHANGE_NOT_INVOICED`.
+ *
+ * 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 online
+ * payment made with the same gateway, method and saved payment method is reused, and retries do not
+ * apply credit grants or balance twice. Paying any other way cancels that earlier online payment
+ * first; if the gateway had already collected it, the invoice is paid by it and nothing more is
+ * charged. One the gateway is still processing is refused with `BILLING_PAYMENT_PENDING` and
+ * `meta.transaction_id`; wait for its outcome.
+ *
+ * Calling this on an invoice that is already paid returns the existing payment result without
+ * another charge. A void invoice is 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`. A renewal invoice is also refused with
+ * `BILLING_INVOICE_NOT_PAYABLE` while its subscription is being canceled, is being reclaimed or has
+ * ended, with `meta.reason` `subscription_canceling`, `subscription_reclaiming` or
+ * `subscription_ended` respectively. A usage invoice is billed to the smallest fraction a balance can
+ * hold, finer than a payment method can charge, so paying one online is refused with
+ * `BILLING_INVOICE_NOT_PAYABLE` and `meta.reason` `usage_invoice`; it is collected from credit grants
+ * and balance automatically, including right after a top-up.
+ * @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.
+ *
+ * A draft order invoice is priced as paying it with the same promotion_code would price it.
+ *
+ * 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. The draft invoice of a deferred order takes the best applicable
+ * account discount and is issued first, and stays issued if the payment fails; pay it on its own to
+ * apply a promotion code.
+ *
+ * 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.
+ * A total different from expected_amount fails with `BILLING_AMOUNT_CHANGED` and nothing is charged.
+ * Invoices that are already paid are not charged again. An online payment started earlier for one
+ * of the invoices is canceled first; one the gateway is still processing is refused with
+ * `BILLING_PAYMENT_PENDING` and `meta.transaction_id`, a void invoice with
+ * `BILLING_INVOICE_NOT_PAYABLE`, a deferred period-end change not yet due to be invoiced with
+ * `BILLING_CHANGE_NOT_INVOICED`, 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`. A renewal invoice is refused with
+ * `BILLING_INVOICE_NOT_PAYABLE` while its subscription is being canceled, is being reclaimed or has
+ * ended, with `meta.reason` `subscription_canceling`, `subscription_reclaiming` or
+ * `subscription_ended` respectively.
+ * @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`;
+};
+/**
+ * Paginated issued invoices belonging to owned billing accounts, filtered by billing_account_id, subscription_id, status and creation interval. Drafts are excluded, including the draft invoice of an order awaiting payment, which is reached through its order; top-ups do not create 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))}`;
+};
+/**
+ * Returns an invoice for an owned billing account with its amounts, tax lines and payment state, whether issued or the draft invoice of an order. Returns 404 for a missing invoice or another draft and 403 when its account belongs to another user.
+ * @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`;
+};
+/**
+ * Paginated lines of an invoice belonging to an owned billing account, issued or the draft invoice of an order, including their service periods and project references. A missing invoice or another draft returns 404; another user account returns 403.
+ * @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`;
+};
+/**
+ * Paginated ledger entries for owned billing accounts, optionally filtered by billing_account_id and creation interval. Each entry retains its amount, currency and any referenced credit grant.
+ * @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 getListCreditNotesUrl = (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-notes?${stringifiedParams}`
+        : `https://billing.leaflow.cloud/api/v1/credit-notes`;
+};
+/**
+ * Newest issued_at first, then ID. Requires authorization for the invoice's billing account. Filters narrow authorized results and apply before counting and paging.
+ * @summary List credit notes
+ */
+export const listCreditNotes = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListCreditNotesUrl(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 getGetCreditNoteUrl = (creditNoteId) => {
+    return `https://billing.leaflow.cloud/api/v1/credit-notes/${encodeURIComponent(String(creditNoteId))}`;
+};
+/**
+ * Requires authorization for the invoice's billing account.
+ * @summary Get credit note
+ */
+export const getCreditNote = async (creditNoteId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetCreditNoteUrl(creditNoteId), {
+        ...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 getListCreditNoteItemsUrl = (creditNoteId, 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-notes/${encodeURIComponent(String(creditNoteId))}/items?${stringifiedParams}`
+        : `https://billing.leaflow.cloud/api/v1/credit-notes/${encodeURIComponent(String(creditNoteId))}/items`;
+};
+/**
+ * The original invoice lines reduced by this note. Requires authorization for their invoice's billing account.
+ * @summary List credit note items
+ */
+export const listCreditNoteItems = async (creditNoteId, params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListCreditNoteItemsUrl(creditNoteId, 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`;
+};
+/**
+ * Lists priced usage charges in the requested financial scope. Usage without a price at occurrence time is never charged retrospectively.
+ * @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`;
+};
+/**
+ * Lists subscriptions visible to the authorized billing account. Soft-deleted subscriptions are excluded.
+ * @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))}`;
+};
+/**
+ * Returns a subscription visible to the authorized billing account. Soft-deleted subscriptions are reported as not found.
+ * @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 getDeleteSubscriptionUrl = (subscriptionId) => {
+    return `https://billing.leaflow.cloud/api/v1/subscriptions/${encodeURIComponent(String(subscriptionId))}`;
+};
+/**
+ * Sets deleted_at on a canceled or terminated subscription, hiding it from your subscription
+ * list and detail. Your account access token must authorize the subscription's current billing
+ * account. Preserves commercial status, ended_at and billing and financial history. Completed
+ * cancellations and canceled unfulfilled purchases can be deleted directly, without termination.
+ * Pending, provisioning, active and suspended subscriptions are refused with 409
+ * BILLING_SUBSCRIPTION_NOT_ENDED and status in error params. A scheduled or releasing cancellation
+ * does not make a subscription canceled.
+ * There is no force, skip-cleanup or override option. Repeating deletion preserves the original
+ * deleted_at. Sends no cleanup command and creates no refund; outstanding cleanup continues.
+ * @summary Delete subscription
+ */
+export const deleteSubscription = async (subscriptionId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDeleteSubscriptionUrl(subscriptionId), {
+        ...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 getCancelSubscriptionUrl = (subscriptionId) => {
+    return `https://billing.leaflow.cloud/api/v1/subscriptions/${encodeURIComponent(String(subscriptionId))}/cancel`;
+};
+/**
+ * Requests cancellation on the purchase's agreed terms. Uses the same quotation, eligibility,
+ * metering and original-payment-source refund rules as creating a cancellation.
+ * Supply the refund amount from create-quote with this subscription in cancellation.subscription_ids.
+ * Your account access token must authorize the subscription's current billing account.
+ *
+ * Immediate cancellation asks the owning service to clean up now. Period-end cancellation keeps
+ * the subscription active or suspended until the paid term ends. Neither payment nor acceptance
+ * of this request proves cleanup. The subscription becomes canceled only after the service
+ * confirms release and the end of metering; follow the returned cancellation for progress.
+ *
+ * Related subscriptions released together must be submitted as one group to create-cancellation.
+ * Pending or provisioning purchases are canceled through their order, not this operation.
+ * Repeating the same open cancellation returns it without another refund or command.
+ * @summary Cancel subscription
+ */
+export const cancelSubscription = async (subscriptionId, cancelSubscriptionRequest, 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)(getCancelSubscriptionUrl(subscriptionId), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(cancelSubscriptionRequest),
+    });
+    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, an existing order, 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 when paying the order's invoice. An order whose terms are fixed 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.reason` `reclaim_requested`), or has a paid
+ *   change still waiting to switch (`meta.order_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))}`;
+};
+/**
+ * Returns a cancellation for an authorized billing account with its schedule, expected refundable amount and individual subscription outcomes. Read individual item states for per-subscription outcomes, including partial success.
+ * @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 current_term_end 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.
+ * Pay its invoice to renew; a promotion code can be applied when paying. 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, applying an applicable account discount first if the
+ * order's terms are not fixed yet.
+ *
+ * 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 for an active or suspended subscription. A pending or provisioning
+ * subscription cannot set this preference and returns 409 `BILLING_SUBSCRIPTION_AUTO_RENEW_INACTIVE`. Disabling it does
+ * not shorten current_term_end and still permits manual renewal. A postpaid subscription always continues until it is
+ * canceled; setting it is refused with 409
+ * `BILLING_SUBSCRIPTION_AUTO_RENEW_FIXED`.
+ *
+ * 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. A pending order is not yet accepted;
+ * its invoice shows whether it still needs payment. accepted means accepted, not delivered.
+ * 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))}`;
+};
+/**
+ * Returns an order charged to an owned billing account with its commercial state and invoice reference. An unknown order returns 404; an order on another user account is forbidden.
+ * @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 getCancelOrderUrl = (orderId) => {
+    return `https://billing.leaflow.cloud/api/v1/orders/${encodeURIComponent(String(orderId))}/cancel`;
+};
+/**
+ * Cancels the selected, still-undelivered items of an unaccepted order without recording a
+ * delivery failure. Omit order_item_ids to select every still-pending item, or name one or
+ * more items. Successful items remain delivered and are not refunded. Whole-order and partial
+ * cancellation both require confirmed non-delivery and necessary cleanup. The order keeps
+ * its existing pending phase while any item is still pending; its final outcome follows all
+ * item outcomes. Previously failed items keep their failure outcome.
+ *
+ * Payment may be absent, partial or complete. Once the order's terms are fixed, the selected items
+ * keep their agreed amounts and discounts; credit notes reduce issued invoices, and collected amounts
+ * are returned to their original payment sources. While the terms of a deferred order are not fixed,
+ * the remaining items are priced again. External payment-method refunds can finish asynchronously. An online payment still waiting for the payer is canceled with the order; one the gateway is already processing is refused with `BILLING_PAYMENT_PENDING` and `meta.transaction_id`.
+ * The order and financial history are retained; the same cancellation does not refund twice.
+ *
+ * Once the order is accepted, its owning service coordinates cancellation and confirms
+ * non-delivery and cleanup through the cancellation RPC. Delivered items are ended through
+ * subscription cancellation. Unknown delivery or payment outcomes are not refund evidence;
+ * in-flight or unknown payments must be reconciled first. Scheduled changes continue to be
+ * canceled through the owning service. Refund quotations use CreateQuote.refund.
+ * @summary Cancel order
+ */
+export const cancelOrder = async (orderId, orderCancel, 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)(getCancelOrderUrl(orderId), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(orderCancel),
+    });
+    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 and active feature grants rather than stored, so this always
+ * agrees with what is being paid for and granted. It stops being listed as soon as the
+ * subscription or grant 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 getListFeatureGrantsUrl = (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/feature-grants?${stringifiedParams}`
+        : `https://billing.leaflow.cloud/api/v1/feature-grants`;
+};
+/**
+ * Access to 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 the
+ * features of its own subscriptions.
+ * @summary List feature grants
+ */
+export const listFeatureGrants = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListFeatureGrantsUrl(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`;
+};
+/**
+ * Paginated registered catalog products with their service identities and descriptions. Supports If- None-Match and returns 304 when the selected page has not changed.
+ * @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`;
+};
+/**
+ * Paginated active plans for the required product_id, with their feature allocations. An unknown product returns 404; If-None-Match can return 304 for an unchanged page.
+ * @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`;
+};
+/**
+ * Sums priced usage for one billing account by UTC day, including usage not yet invoiced. Amounts are
+ * before tax and before the tier adjustments made when a statement closes; minimum charges added at
+ * closing are included. `from` and `to` must fall on UTC day boundaries and span at most 92 days.
+ * Project filters use the account recorded on each charge, including charges for projects later
+ * assigned to another account. The total covers all matching groups, not just the returned page.
+ * @summary List account spend
+ */
+export 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 };
+};
+export const getListMonthlyStatementsUrl = (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/monthly-statements?${stringifiedParams}`
+        : `https://billing.leaflow.cloud/api/v1/monthly-statements`;
+};
+/**
+ * Usage billing by UTC calendar month for owned billing accounts, newest first. Each period combines its statements, the invoices they issued and how those invoices were paid; usage is billed about hourly, so a month holds many statements. Filter by billing_account_id and by period start.
+ * @summary List monthly statements
+ */
+export const listMonthlyStatements = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListMonthlyStatementsUrl(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 getListStatementsUrl = (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/statements?${stringifiedParams}`
+        : `https://billing.leaflow.cloud/api/v1/statements`;
+};
+/**
+ * Paginated consumption statement batches for owned billing accounts, filtered by billing_account_id, open or closed state and period-start interval. A closed batch is not proof that the whole month has finished.
+ * @summary List statements
+ */
+export const listStatements = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListStatementsUrl(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 getGetStatementUrl = (statementId) => {
+    return `https://billing.leaflow.cloud/api/v1/statements/${encodeURIComponent(String(statementId))}`;
+};
+/**
+ * Returns an owned-account consumption batch with its period, estimated or closed amounts and invoice reference. Returns 404 for a missing batch and 403 when the billing account belongs to another user.
+ * @summary Get statement
+ */
+export const getStatement = async (statementId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetStatementUrl(statementId), {
+        ...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 getGetStatementUsageUrl = (statementId, params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        const explodeParameters = ["project_ids"];
+        if (Array.isArray(value) && explodeParameters.includes(key)) {
+            value.forEach((v) => {
+                normalizedParams.append(key, v === null ? "null" : String(v));
+            });
+            return;
+        }
+        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/statements/${encodeURIComponent(String(statementId))}/usage-summary?${stringifiedParams}`
+        : `https://billing.leaflow.cloud/api/v1/statements/${encodeURIComponent(String(statementId))}/usage-summary`;
+};
+/**
+ * Reads the consumption summary that is updated in the same transaction as usage is priced. Group by project, product or meter and filter within the statement. Quantities are included only for meter groups so different units are never combined.
+ * @summary Get grouped consumption
+ */
+export const getStatementUsage = async (statementId, params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetStatementUsageUrl(statementId, 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 };
+};