@leaflow/sdk 0.0.0-dev.35.g30ba751 → 0.0.0-dev.353.g74313e0

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

@@ -0,0 +1,2169 @@
+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`;
+};
+/**
+ * The withdrawal's items and their outcomes. A failed item does not undo refunds completed through other items.
+ * @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`;
+};
+/**
+ * Withdrawals, newest first.
+ * @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 balance through the original top-ups, oldest first, with fees calculated per source. expected_items and expected_refund_amount must match the preview. Reusing the ID with different terms fails. Only successful items are charged a fee.
+ * @summary Create withdrawal
+ */
+export 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 balance deduction, fees and refund split by original top-up. Omit amount to preview all available balance. Nothing is created or reserved. Fails when a selected source has no refund route or its original processing cost is not yet known.
+ * @summary Preview withdrawal
+ */
+export 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: "QUERY",
+        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))}`;
+};
+/**
+ * A withdrawal with its accepted amounts and overall outcome; list its items for each 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`;
+};
+/**
+ * Contacts of the billing account, inactive ones included. 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 for the billing account. To use it on invoices, set the account's invoice_contact_id.
+ * @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))}`;
+};
+/**
+ * A contact of this billing account. Returns 404 if it does not exist in the 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 of this billing account. Returns 404 if it does not exist in the 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 of this billing account; 404 if it does not exist in the account. A contact selected for invoices must be cleared or replaced first. Issued invoices keep their copy.
+ * @summary Delete contact
+ */
+export 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`;
+};
+/**
+ * Currencies a new billing account can be opened in; retired currencies are not listed.
+ * @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`;
+};
+/**
+ * Billing accounts owned by the authenticated user.
+ * @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`;
+};
+/**
+ * Creates a billing account. Its currency is fixed: prices, orders, invoices and balance are all in it.
+ * @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))}`;
+};
+/**
+ * Your billing account with its currency, status and invoice contact. Returns 404 if it 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))}`;
+};
+/**
+ * Selects an active contact of this account for future invoices; its legal name, address and tax identifier are copied when an invoice is issued. Set invoice_contact_id to null to clear it. The currency cannot change.
+ * @summary Update billing account
+ */
+export 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`;
+};
+/**
+ * The balance of your account, with credit groups, unpaid invoice amounts, unbilled estimates and pending returns. Returns 404 for a missing account and 403 for another user's account.
+ * @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`;
+};
+/**
+ * The payment gateways and methods currently accepting the account's currency, preferred gateway first. Top-ups and invoice payments must use one listed here. An empty result means online payment is unavailable for the account.
+ * @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`;
+};
+/**
+ * Current project assignments to your billing accounts, filtered by billing_account_id or project_ids. Past charges keep the account they were assigned to.
+ * @summary List project assignments
+ */
+export 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))}`;
+};
+/**
+ * The project's current assignment. Returns 404 when no billing account is assigned; the project cannot create resources until one is.
+ * @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))}`;
+};
+/**
+ * Links the project to another billing account. Charges already incurred stay with the account linked when they
+ * occurred and are invoiced to it; metered resources are settled up to the moment of the change. Amounts the
+ * previous account owes do not prevent the change. Orders keep the account they were placed with; paid periods
+ * are unaffected, and renewals are charged to the new account.
+ *
+ * Refused once the project no longer accepts purchases because it is being deleted, and while a subscription or
+ * an in-progress order of the project uses a currency other than the new account's.
+ * @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; the assignment history is kept. Allowed only when the project has no metered resources, no subscriptions that have not ended and no orders in progress, including period-end changes; orders are not modified, so wait for them to complete. Charges already incurred stay with the billing account and are invoiced as usual; amounts it owes do not prevent unlinking. 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`;
+};
+/**
+ * Your top-ups, including pending, failed and canceled attempts. Items carry no `action`; read a pending top-up with get-top-up to continue its payment.
+ * @summary List top ups
+ */
+export 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 of the authenticated user and returns its payment information. The balance increases when the gateway confirms receipt. Keep the supplied ID to read the attempt after a lost response; creating it again conflicts.
+ * @summary Create top up
+ */
+export 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))}`;
+};
+/**
+ * A top-up of the authenticated user, with its outcome and unspent amount. While it is pending, `action` carries the customer's next step as the gateway reports it, so an interrupted payment can be continued; when the gateway cannot be reached, `action` is omitted.
+ * @summary Get top up
+ */
+export 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 of the authenticated user at the payment gateway. It becomes `canceled` with
+ * `cancellation_reason` `requested_by_customer`, and nothing is collected. Canceling a canceled top-up returns
+ * it unchanged. If the gateway has already collected the payment, the top-up is returned as `succeeded` with the
+ * balance increased; check `status` in the response.
+ *
+ * Fails with 409 `BILLING_TOPUP_NOT_CANCELABLE` when the top-up has succeeded or failed, with `status` naming
+ * the outcome, or while the gateway is processing the payment, with `status` `pending`; read the top-up again
+ * later.
+ * @summary Cancel top up
+ */
+export 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`;
+};
+/**
+ * Saved payment methods of your billing accounts, optionally for one billing_account_id. Removed methods are not listed.
+ * @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 the browser needs to open the payment gateway's card form. Nothing is charged; the method is listed once the gateway confirms it. Card numbers never reach this service.
+ * @summary Create payment method setup
+ */
+export 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`;
+};
+/**
+ * Makes an active saved payment method the default for its billing account and returns it. Expired or removed methods cannot be selected; selecting the current default changes nothing.
+ * @summary Set default payment method
+ */
+export 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 payment method of an account with metered resources.
+ * @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`;
+};
+/**
+ * Pays the invoice from eligible credit grants and balance as requested, and collects the remainder through the
+ * selected gateway and method. Without a gateway, insufficient funds fail and no online payment starts.
+ *
+ * The draft invoice of a deferred order is priced on its first payment: promotion_code, or otherwise the best
+ * applicable account discount, is applied, the total is compared with expected_amount, and the invoice is issued
+ * before collection. An invalid or inapplicable code fails, and a total other than expected_amount fails with
+ * `BILLING_AMOUNT_CHANGED`; neither changes anything. Once fixed, the terms stay fixed even if collection does
+ * not complete, and a different promotion_code is refused with `BILLING_ORDER_CHECKOUT_CONFLICT`. A deferred
+ * period-end change can be paid only once its first period is due to be invoiced; earlier attempts fail with
+ * `BILLING_CHANGE_NOT_INVOICED`.
+ *
+ * Returns a payment action when the customer must act; requires_action and processing are not paid. An
+ * unresolved online payment with the same gateway, method and saved payment method is reused, and retries never
+ * apply credit grants or balance twice. Paying any other way first cancels that payment; if the gateway had
+ * already collected it, the invoice is paid by it and nothing more is charged. A payment the gateway is still
+ * processing fails with `BILLING_PAYMENT_PENDING` and `meta.transaction_id`.
+ *
+ * A paid invoice returns its existing result without another charge. Refused with `BILLING_INVOICE_NOT_PAYABLE`
+ * for a void invoice; `BILLING_ORDER_FAILED` or `BILLING_ORDER_CANCELED` for the invoice of a failed or canceled
+ * order; `BILLING_ORDER_EXPIRED` after the order's payment deadline; `BILLING_INVOICE_NOT_PAYABLE` with
+ * `meta.reason` `subscription_canceling`, `subscription_reclaiming` or `subscription_ended` for a renewal
+ * invoice whose subscription is being canceled, is being reclaimed or has ended; and
+ * `BILLING_INVOICE_NOT_PAYABLE` with `meta.reason` `usage_invoice` for a usage invoice, which 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 those of the listed orders, from eligible credit grants and then balance,
+ * without a payment gateway. The draft invoice of a deferred order takes the best applicable account discount
+ * and is issued first, staying issued if payment fails; pay it alone to use a promotion code.
+ *
+ * All invoices are paid or none: insufficient funds fail with `BILLING_INSUFFICIENT_FUNDS`, and a total other
+ * than expected_amount fails with `BILLING_AMOUNT_CHANGED`, charging nothing. Paid invoices are not charged
+ * again. An earlier online payment for one of the invoices is canceled first; one the gateway is still
+ * processing is refused with `BILLING_PAYMENT_PENDING` and `meta.transaction_id`. Also refused with
+ * `BILLING_INVOICE_NOT_PAYABLE` for a void invoice; `BILLING_CHANGE_NOT_INVOICED` for a period-end change not
+ * yet due; `BILLING_ORDER_FAILED`, `BILLING_ORDER_CANCELED` or `BILLING_ORDER_EXPIRED` for an order in that
+ * state; and `BILLING_INVOICE_NOT_PAYABLE` with `meta.reason` `subscription_canceling`,
+ * `subscription_reclaiming` or `subscription_ended` for a renewal invoice of a subscription being canceled,
+ * being reclaimed or ended.
+ * @summary Pay together
+ */
+export 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, per invoice in payment order, calculated as paying together does. Nothing is charged, reserved or created. Refused with the same errors as paying together, except that insufficient funds show as a `gateway_amount` above zero instead of an error.
+ * @summary Preview paying together
+ */
+export 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: "QUERY",
+        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`;
+};
+/**
+ * Issued invoices of your billing accounts. Drafts are not listed; an order's draft invoice is reached through its order. Top-ups have no 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))}`;
+};
+/**
+ * An invoice of your billing account, issued or an order's draft, with its amounts, tax lines and payment state. A missing invoice or another draft returns 404; an invoice of another user's account returns 403.
+ * @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`;
+};
+/**
+ * Lines of an invoice of your billing account, issued or an order's draft, with their service periods and projects. A missing invoice or another draft returns 404; an invoice of another user's 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`;
+};
+/**
+ * Ledger entries of your billing accounts, filtered by billing_account_id and creation time.
+ * @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 held by the account, applied at checkout without a code. Coupons reached through a code are not listed.
+ * @summary List the coupons held on this account
+ */
+export 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`;
+};
+/**
+ * Credit grants with what remains and what each may pay for. Credit is spent before balance and cannot be withdrawn.
+ * @summary List credit grants
+ */
+export 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`;
+};
+/**
+ * Credit notes, newest first. Filters apply within the billing accounts you are authorized for.
+ * @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 invoice lines this credit note reduced.
+ * @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`;
+};
+/**
+ * Priced usage charges in the requested scope. Usage that had no price when it occurred is never charged later.
+ * @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`;
+};
+/**
+ * Subscriptions of the authorized billing account. Deleted subscriptions are not listed.
+ * @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))}`;
+};
+/**
+ * A subscription of the authorized billing account. 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))}`;
+};
+/**
+ * Hides a canceled or terminated subscription from your subscription list and detail by setting deleted_at; its status, ended_at and history are kept. The token must authorize the subscription's current billing account. A subscription that has not ended is refused with 409 `BILLING_SUBSCRIPTION_NOT_ENDED` and `status`. Repeating it keeps the original deleted_at. It sends no cleanup command and creates no refund.
+ * @summary Delete subscription
+ */
+export 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, with the same rules as creating a cancellation. Give the
+ * refund amount from a quote with this subscription in `cancellation.subscription_ids`. The token must authorize
+ * the subscription's current billing account.
+ *
+ * Immediate cancellation asks the owning service to release the resources now; period-end cancellation keeps the
+ * subscription active or suspended until the paid term ends. The subscription becomes canceled when the service
+ * confirms the release; follow the returned cancellation. Subscriptions released together must be canceled
+ * together through create-cancellation, and pending or provisioning purchases through their order. Repeating the
+ * request while the cancellation is open returns it.
+ * @summary Cancel subscription
+ */
+export 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 getGetQuoteUrl = () => {
+    return `https://billing.leaflow.cloud/api/v1/quotes`;
+};
+/**
+ * Calculates exactly one target for a billing account you own: proposed items, an existing order, renewals, a
+ * cancellation or an order refund. Nothing is saved, reserved or redeemed.
+ *
+ * Existing orders use their recorded account and terms; renewals and cancellations use the account currently
+ * paying for each subscription. Every target must belong to the requested account; a project token does not
+ * authorize a quote. An existing order's total is the expected_amount for paying its invoice. Usage estimates
+ * are not checkout amounts.
+ * @summary Get a quote
+ */
+export const getQuote = 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)(getGetQuoteUrl(), {
+        ...options,
+        method: "QUERY",
+        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 a subscription's cancellation in progress.
+ * @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 subscriptions of one service together. Deleting a resource is an `immediate` cancellation of every
+ * subscription released with it, such as a server with its disks or an address with its bandwidth.
+ *
+ * The owning service releases the resources at once for `immediate`, or at `scheduled_at`, the end of the paid
+ * term, for `period_end`. When release is confirmed, the unused value is returned to the original payment
+ * sources under each subscription's refund terms. For `immediate` the refund is computed as of `proration_date`
+ * and is not reduced by service used during release. Metered usage is charged until release.
+ *
+ * `mode` must be allowed for every subscription. Metered and one-time subscriptions end only `immediate`. A
+ * licensed subscription ends `period_end` while its paid term lasts, and `immediate` unless its terms allow only
+ * the end of the paid term and that term has not ended. For `period_end` all paid terms must end at the same
+ * time.
+ *
+ * Refused with:
+ *
+ * - 400 `BILLING_CANCELLATION_INVALID` when `subscription_ids` or `proration_date` is invalid (`meta.field`), or
+ *   the subscriptions do not share one service, project, account and currency;
+ * - 409 `BILLING_CANCELLATION_CONFLICT` when a subscription has not started or has ended;
+ * - 422 `BILLING_CANCELLATION_MODE_FIXED` when `mode` is not allowed, and `BILLING_CANCELLATION_TERMS_UNSET`
+ *   when a licensed subscription has no termination terms, both with `meta.subscription_id`;
+ * - 409 `BILLING_CANCELLATION_SCHEDULES_DIFFER` when, for `period_end`, the paid terms end at different times;
+ * - 409 `BILLING_SUBSCRIPTION_OPERATION_PENDING` when a subscription is already being canceled
+ *   (`meta.cancellation_id`) or reclaimed (`meta.reason` `reclaim_requested`), or has a paid change waiting to
+ *   switch (`meta.order_id`);
+ * - 409 `BILLING_ORDER_PAYMENT_IN_FLIGHT` while an online renewal payment for one of them is in progress;
+ * - 409 `BILLING_CANCELLATION_REFUND_CHANGED` when the refund no longer equals `expected_refundable_amount`.
+ *
+ * Repeating the request for the same subscriptions, mode and amount while the cancellation is open returns it
+ * with 200. Unpaid renewal orders are canceled with it, and automatic renewal is turned off for every
+ * subscription.
+ * @summary Cancel subscriptions
+ */
+export 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))}`;
+};
+/**
+ * A cancellation of your billing account with its schedule, expected refundable amount and the outcome for each subscription, 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 no resource has begun to be released; afterwards it is refused with 409 `BILLING_CANCELLATION_CONFLICT`. The subscriptions continue, but automatic renewal, turned off when the cancellation was created, stays off until it is turned on again. Withdrawing a withdrawn cancellation returns it unchanged.
+ * @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`;
+};
+/**
+ * Buys licensed periods from current_term_end at the agreed recurring amount and pays for them at once. A
+ * different interval selects the price currently sold for it and fixes new terms on the order, applied after
+ * fulfillment. Paid periods keep their value.
+ *
+ * Without `payment_method_id`, the renewal is paid from credit grants and balance as `use_credits` and
+ * `use_balance` allow; when they cannot cover it, the request fails with `BILLING_INSUFFICIENT_FUNDS` and no
+ * order is left. To pay another way, create a renewal order and pay its invoice.
+ *
+ * Keep order_id and read the order after an unknown outcome; creating it again 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 discounts are kept.
+ * 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 its terms are not fixed yet.
+ *
+ * Keep `order_id` and read the order after an unknown outcome; creating it again 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`;
+};
+/**
+ * Turns automatic renewal of an active or suspended licensed subscription on or off. Turning it off does not shorten current_term_end and still allows manual renewal. Refused with 409 `BILLING_SUBSCRIPTION_AUTO_RENEW_INACTIVE` for a pending or provisioning subscription, 409 `BILLING_SUBSCRIPTION_AUTO_RENEW_FIXED` for a metered subscription, which continues until it is canceled, and 409 `BILLING_SUBSCRIPTION_OPERATION_PENDING` with `meta.cancellation_id` while a cancellation is open: creating it turned renewal off, and withdrawing it does not turn renewal back on.
+ * @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`;
+};
+/**
+ * Remaining usage quantities, such as bytes, seconds or tokens. Applicable allowances are consumed before usage is charged: lower priority values first, then earlier expiry, then earlier issuance. Unused quantity expires without refund or carry-over. Promotional allowances apply to usage paid by their holding account; included allowances apply only to their subscription, also after its project moves to another billing account.
+ * @summary List allowances
+ */
+export 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`;
+};
+/**
+ * Orders with their status and invoice amounts. A pending order is not yet accepted and can expire at expires_at; its invoice shows whether payment is needed. Accepted does not mean delivered.
+ * @summary List orders
+ */
+export 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))}`;
+};
+/**
+ * An order of your billing account with its status and invoice. An unknown order returns 404; another user's order returns 403.
+ * @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 undelivered items of an order that has not been accepted, without recording a delivery
+ * failure. Omit order_item_ids to select every pending item. Delivered items stay delivered and are not
+ * refunded; failed items keep their outcome. The order stays pending while any item is pending, and its final
+ * status follows its items.
+ *
+ * Once the order's terms are fixed, the canceled items keep their agreed amounts and discounts: credit notes
+ * reduce the issued invoice, and collected amounts return to their original payment sources, possibly
+ * asynchronously. While a deferred order's terms are not fixed, the remaining items are priced again. An online
+ * payment waiting for the payer is canceled with the order; one the gateway is processing is refused with
+ * `BILLING_PAYMENT_PENDING` and `meta.transaction_id`. Repeating the cancellation does not refund twice.
+ *
+ * An accepted order is canceled by its owning service, and delivered items through subscription cancellation.
+ * Refunds are quoted with the quote operation's `refund` target.
+ * @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 granted by live subscriptions and active feature grants. A capability not held is not listed, and one stops being listed when 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`;
+};
+/**
+ * Features held by a billing account for a period, for example through a membership. While a grant is active, every project whose current billing account holds it has the feature, in addition to its subscriptions' features.
+ * @summary List feature grants
+ */
+export 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 active price in the currency, one entry per plan and price. Archived prices are not listed; existing subscriptions keep the terms they were bought at.
+ * @summary List what is on sale, with prices
+ */
+export 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`;
+};
+/**
+ * Registered products. If-None-Match returns 304 for an unchanged page.
+ * @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))}`;
+};
+/**
+ * A product by its ID.
+ * @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))}`;
+};
+/**
+ * A plan, including one no longer on sale.
+ * @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))}`;
+};
+/**
+ * A catalog price, archived prices included. The terms of past purchases are on their orders and subscriptions.
+ * @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`;
+};
+/**
+ * Active plans of product_id with their features. An unknown product returns 404; If-None-Match returns 304 for an unchanged page.
+ * @summary List catalog plans
+ */
+export 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. An account with a negotiated agreement may be charged less, never 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`;
+};
+/**
+ * Rules of a public rate card; contract cards are not readable here.
+ * @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`;
+};
+/**
+ * Continuous metering registrations paid for by your billing accounts. Their state does not describe the resource's runtime. Project filters only narrow the result.
+ * @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 per UTC calendar month for your billing accounts, newest first. Each month combines its statements, the invoices they issued and how those were paid.
+ * @summary List monthly statements
+ */
+export 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`;
+};
+/**
+ * Statements of your billing accounts, filtered by billing_account_id, open or closed and period start. A closed statement does not mean the month is complete.
+ * @summary List statements
+ */
+export 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))}`;
+};
+/**
+ * A statement of your billing account with its period, estimated or closed amounts and invoice. Returns 404 for a missing statement and 403 for another user's account.
+ * @summary Get statement
+ */
+export 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`;
+};
+/**
+ * The statement's consumption, grouped by project, product or meter and filtered within the statement. Quantities are given only for meter groups; grouping by meter also splits by the meter's presentation dimensions.
+ * @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 };
+};