@leaflow/sdk 0.153.0 → 0.155.0

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

@@ -772,15 +772,9 @@ export const getPayInvoiceUrl = (invoiceId) => {
 };
 /**
  * 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`.
+ * selected gateway and method. Without a gateway, insufficient funds fail and no online payment starts. The
+ * invoice's amounts and discount were fixed when it was issued and are not changed by paying; promotion codes
+ * are applied when completing a Checkout Session.
  *
  * Returns a payment action when the customer must act; requires_action and processing are not paid. An
  * unresolved online payment with the same gateway, method and saved payment method is reused, and retries never
@@ -793,8 +787,9 @@ export const getPayInvoiceUrl = (invoiceId) => {
  * 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.
+ * `BILLING_INVOICE_NOT_PAYABLE` with `meta.reason` `fractional_amount` when the amount left for the gateway is
+ * not a whole number of the currency's minor unit; such an invoice is collected from credit grants and balance
+ * automatically, including right after a top-up.
  * @summary Pay an invoice
  */
 export const payInvoice = async (invoiceId, payInvoiceRequest, options, fetchFn) => {
@@ -841,8 +836,6 @@ export const getPreviewInvoicePaymentUrl = (invoiceId, params) => {
  * 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
@@ -861,15 +854,13 @@ export const getPayTogetherUrl = () => {
 };
 /**
  * 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.
+ * without a payment gateway.
  *
  * All invoices are paid or none: insufficient funds fail with `BILLING_INSUFFICIENT_FUNDS`, and a total other
  * than expected_amount fails with `BILLING_AMOUNT_CHANGED`, charging nothing. Paid invoices are not charged
  * again. An earlier online payment for one of the invoices is canceled first; one the gateway is still
  * processing is refused with `BILLING_PAYMENT_PENDING` and `meta.transaction_id`. Also refused with
- * `BILLING_INVOICE_NOT_PAYABLE` for a void invoice; `BILLING_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
+ * `BILLING_INVOICE_NOT_PAYABLE` for a void invoice; `BILLING_ORDER_FAILED`, `BILLING_ORDER_CANCELED` or `BILLING_ORDER_EXPIRED` for an order in that
  * state; and `BILLING_INVOICE_NOT_PAYABLE` with `meta.reason` `subscription_canceling`,
  * `subscription_reclaiming` or `subscription_ended` for a renewal invoice of a subscription being canceled,
  * being reclaimed or ended.
@@ -947,7 +938,7 @@ export const getListInvoicesUrl = (params) => {
         : `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.
+ * Issued invoices of your billing accounts. Top-ups have no invoices.
  * @summary List invoices
  */
 export const listInvoices = async (params, options, fetchFn) => {
@@ -963,7 +954,7 @@ 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.
+ * An issued invoice of your billing account, with its amounts, tax lines and payment state. A missing or unissued invoice returns 404; an invoice of another user's account returns 403.
  * @summary Get invoice
  */
 export const getInvoice = async (invoiceId, options, fetchFn) => {
@@ -988,7 +979,7 @@ export const getListInvoiceItemsUrl = (invoiceId, params) => {
         : `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.
+ * Lines of an issued invoice of your billing account, with their service periods and projects. A missing or unissued invoice returns 404; an invoice of another user's account returns 403.
  * @summary List invoice items
  */
 export const listInvoiceItems = async (invoiceId, params, options, fetchFn) => {
@@ -1293,13 +1284,17 @@ 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.
+ * Calculates what a proposed purchase, or the renewal of your subscriptions, would invoice now, and what each
+ * purchased line renews at. 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.
+ * With `billing_account_id`, the quote is for a billing account you own: its currency, account discounts,
+ * tax and funds apply, renewals use the account currently paying for each subscription, and an access token
+ * is required. Without it, proposed items are priced in `currency` for anyone, signed in or not: no account
+ * discount or funds apply, and `tax_status` is `requires_location_inputs`.
+ *
+ * A promotion code is evaluated without being applied. It is applied only when a Checkout Session is completed
+ * with it; conditions that depend on the account, such as a first purchase, are checked only with an account
+ * and otherwise reported as `unverified`. Future usage of metered prices is estimated with `estimate-usage`.
  * @summary Get a quote
  */
 export const getQuote = async (quoteRequest, options, fetchFn) => {
@@ -1328,6 +1323,42 @@ export const getQuote = async (quoteRequest, options, fetchFn) => {
     const data = body ? JSON.parse(body) : {};
     return { data, status: res.status, headers: res.headers };
 };
+export const getEstimateUsageUrl = () => {
+    return `https://billing.leaflow.cloud/api/v1/usage-estimates`;
+};
+/**
+ * Estimates what future usage of metered prices would cost in `currency` at current rates, for anyone, signed in
+ * or not. Nothing is saved. Graduated and volume tiers apply to the estimated quantity alone, while actual charges
+ * follow each month's whole usage, and the amounts are before discounts and tax. Estimates are not collected at
+ * checkout. An item that cannot be priced fails the whole request.
+ * @summary Estimate usage
+ */
+export const estimateUsage = async (usageEstimateRequest, 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)(getEstimateUsageUrl(), {
+        ...options,
+        method: "QUERY",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(usageEstimateRequest),
+    });
+    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]) => {
@@ -1415,6 +1446,39 @@ export const createCancellation = async (cancellationCreate, options, fetchFn) =
     const data = body ? JSON.parse(body) : {};
     return { data, status: res.status, headers: res.headers };
 };
+export const getPreviewCancellationUrl = () => {
+    return `https://billing.leaflow.cloud/api/v1/cancellations/preview`;
+};
+/**
+ * What creating the cancellation now would return, per subscription and in total. Nothing is canceled, ended or refunded. Refused as creating it would be, except that nothing is recorded.
+ * @summary Preview a cancellation
+ */
+export const previewCancellation = async (cancellationPreviewRequest, 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)(getPreviewCancellationUrl(), {
+        ...options,
+        method: "QUERY",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(cancellationPreviewRequest),
+    });
+    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))}`;
 };
@@ -1482,7 +1546,7 @@ export const getRenewSubscriptionUrl = (subscriptionId) => {
  *
  * 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.
+ * order is left. To apply a promotion code or pay later, create a renewal Checkout Session.
  *
  * Keep order_id and read the order after an unknown outcome; creating it again conflicts.
  * @summary Renew subscription
@@ -1513,21 +1577,14 @@ export const renewSubscription = async (subscriptionId, renewRequest, options, f
     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`;
+export const getSetAutoRenewUrl = (subscriptionId) => {
+    return `https://billing.leaflow.cloud/api/v1/subscriptions/${encodeURIComponent(String(subscriptionId))}/auto-renew`;
 };
 /**
- * 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
+ * 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 createRenewalOrder = async (subscriptionId, renewalOrderRequest, options, fetchFn) => {
+export const setAutoRenew = async (subscriptionId, autoRenewSet, options, fetchFn) => {
     const getHeaders = (h) => {
         if (!h)
             return {};
@@ -1543,24 +1600,80 @@ export const createRenewalOrder = async (subscriptionId, renewalOrderRequest, op
         }
         return headers;
     };
-    const res = await (fetchFn ?? fetch)(getCreateRenewalOrderUrl(subscriptionId), {
+    const res = await (fetchFn ?? fetch)(getSetAutoRenewUrl(subscriptionId), {
         ...options,
-        method: "POST",
+        method: "PUT",
         headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
-        body: JSON.stringify(renewalOrderRequest),
+        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 getSetAutoRenewUrl = (subscriptionId) => {
-    return `https://billing.leaflow.cloud/api/v1/subscriptions/${encodeURIComponent(String(subscriptionId))}/auto-renew`;
+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`;
 };
 /**
- * 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
+ * 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 setAutoRenew = async (subscriptionId, autoRenewSet, options, fetchFn) => {
+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 getListCheckoutSessionsUrl = (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/checkout-sessions?${stringifiedParams}`
+        : `https://billing.leaflow.cloud/api/v1/checkout-sessions`;
+};
+/**
+ * Checkout Sessions of your billing accounts, newest first. An open session is a purchase waiting for you to complete checkout.
+ * @summary List Checkout Sessions
+ */
+export const listCheckoutSessions = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListCheckoutSessionsUrl(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 getCreateCheckoutSessionUrl = () => {
+    return `https://billing.leaflow.cloud/api/v1/checkout-sessions`;
+};
+/**
+ * Opens a Checkout Session renewing one of your licensed subscriptions, with periods and price chosen as in
+ * renewing. Nothing is charged until you complete it, when a promotion code can be applied; it then renews from
+ * the subscription's current_term_end at that time. To renew at once from credit grants, balance or a payment
+ * method, renew the subscription instead. Purchases and changes of a service's resources are created through
+ * that service.
+ *
+ * Keep `checkout_session_id` and read the session after an unknown outcome; creating it again conflicts.
+ * @summary Create a renewal Checkout Session
+ */
+export const createCheckoutSession = async (checkoutSessionCreate, options, fetchFn) => {
     const getHeaders = (h) => {
         if (!h)
             return {};
@@ -1576,17 +1689,33 @@ export const setAutoRenew = async (subscriptionId, autoRenewSet, options, fetchF
         }
         return headers;
     };
-    const res = await (fetchFn ?? fetch)(getSetAutoRenewUrl(subscriptionId), {
+    const res = await (fetchFn ?? fetch)(getCreateCheckoutSessionUrl(), {
         ...options,
-        method: "PUT",
+        method: "POST",
         headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
-        body: JSON.stringify(autoRenewSet),
+        body: JSON.stringify(checkoutSessionCreate),
     });
     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) => {
+export const getGetCheckoutSessionUrl = (checkoutSessionId) => {
+    return `https://billing.leaflow.cloud/api/v1/checkout-sessions/${encodeURIComponent(String(checkoutSessionId))}`;
+};
+/**
+ * A Checkout Session of your billing account. Poll it to follow checkout; once it is complete, read its order for payment and delivery. An unknown session returns 404; another account's session returns 403.
+ * @summary Get a Checkout Session
+ */
+export const getCheckoutSession = async (checkoutSessionId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetCheckoutSessionUrl(checkoutSessionId), {
+        ...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 getListCheckoutSessionItemsUrl = (checkoutSessionId, params) => {
     const normalizedParams = new URLSearchParams();
     Object.entries(params || {}).forEach(([key, value]) => {
         if (value !== undefined) {
@@ -1595,15 +1724,47 @@ export const getListAllowancesUrl = (params) => {
     });
     const stringifiedParams = normalizedParams.toString();
     return stringifiedParams.length > 0
-        ? `https://billing.leaflow.cloud/api/v1/allowances?${stringifiedParams}`
-        : `https://billing.leaflow.cloud/api/v1/allowances`;
+        ? `https://billing.leaflow.cloud/api/v1/checkout-sessions/${encodeURIComponent(String(checkoutSessionId))}/items?${stringifiedParams}`
+        : `https://billing.leaflow.cloud/api/v1/checkout-sessions/${encodeURIComponent(String(checkoutSessionId))}/items`;
 };
 /**
- * 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
+ * What the session buys, by position. Prices and amounts are in its quote.
+ * @summary List Checkout Session items
  */
-export const listAllowances = async (params, options, fetchFn) => {
-    const res = await (fetchFn ?? fetch)(getListAllowancesUrl(params), {
+export const listCheckoutSessionItems = async (checkoutSessionId, params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListCheckoutSessionItemsUrl(checkoutSessionId, 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 getGetCheckoutSessionQuoteUrl = (checkoutSessionId, 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/checkout-sessions/${encodeURIComponent(String(checkoutSessionId))}/quote?${stringifiedParams}`
+        : `https://billing.leaflow.cloud/api/v1/checkout-sessions/${encodeURIComponent(String(checkoutSessionId))}/quote`;
+};
+/**
+ * What completing this open session now would invoice, with `promotion_code` or otherwise the best applicable
+ * account discount, and the account funds available for it. Nothing is applied, reserved or redeemed. An invalid
+ * or inapplicable code fails the request without changing the session.
+ *
+ * Complete the session with the returned `total` as `expected_amount`, the same `promotion_code` and, for an
+ * immediate change, the returned `proration_date`. An expired session is refused with
+ * `BILLING_CHECKOUT_SESSION_EXPIRED`, and a complete one with `BILLING_CHECKOUT_SESSION_COMPLETE`; read its order
+ * instead.
+ * @summary Quote a Checkout Session
+ */
+export const getCheckoutSessionQuote = async (checkoutSessionId, params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetCheckoutSessionQuoteUrl(checkoutSessionId, params), {
         ...options,
         method: "GET",
     });
@@ -1611,6 +1772,63 @@ export const listAllowances = async (params, options, fetchFn) => {
     const data = body ? JSON.parse(body) : {};
     return { data, status: res.status, headers: res.headers };
 };
+export const getConfirmCheckoutSessionUrl = (checkoutSessionId) => {
+    return `https://billing.leaflow.cloud/api/v1/checkout-sessions/${encodeURIComponent(String(checkoutSessionId))}/confirm`;
+};
+/**
+ * Completes an open session: applies `promotion_code`, or otherwise the best applicable account discount, checks
+ * the total against `expected_amount` and creates the order with its invoice issued. A zero-total invoice is paid
+ * at once; otherwise pay the invoice next. A failed payment leaves the order and its terms as they are, and the
+ * invoice can be paid again until the order expires. Nothing is created when the code is invalid or
+ * inapplicable or the total differs, which fails with `BILLING_AMOUNT_CHANGED`.
+ *
+ * Confirming a complete session again with the same terms returns it with its order; different terms are refused
+ * with `BILLING_CHECKOUT_SESSION_COMPLETE`. An expired session is refused with `BILLING_CHECKOUT_SESSION_EXPIRED`.
+ * The order is delivered by the service that owns it once paid; confirmation alone does not mean delivery.
+ * @summary Confirm a Checkout Session
+ */
+export const confirmCheckoutSession = async (checkoutSessionId, checkoutSessionConfirm, 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)(getConfirmCheckoutSessionUrl(checkoutSessionId), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(checkoutSessionConfirm),
+    });
+    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 getExpireCheckoutSessionUrl = (checkoutSessionId) => {
+    return `https://billing.leaflow.cloud/api/v1/checkout-sessions/${encodeURIComponent(String(checkoutSessionId))}/expire`;
+};
+/**
+ * Ends an open session without an order; the service that created it releases what it was holding for the purchase. An expired session is returned unchanged.
+ * @summary Expire a Checkout Session
+ */
+export const expireCheckoutSession = async (checkoutSessionId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getExpireCheckoutSessionUrl(checkoutSessionId), {
+        ...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 getListOrdersUrl = (params) => {
     const normalizedParams = new URLSearchParams();
     Object.entries(params || {}).forEach(([key, value]) => {
@@ -1652,6 +1870,31 @@ export const getOrder = async (orderId, options, fetchFn) => {
     const data = body ? JSON.parse(body) : {};
     return { data, status: res.status, headers: res.headers };
 };
+export const getPreviewOrderRefundUrl = (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))}/refund-preview?${stringifiedParams}`
+        : `https://billing.leaflow.cloud/api/v1/orders/${encodeURIComponent(String(orderId))}/refund-preview`;
+};
+/**
+ * What canceling the listed items, or the whole order, would refund to the original payment sources. Nothing is canceled or refunded.
+ * @summary Preview an order refund
+ */
+export const previewOrderRefund = async (orderId, params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getPreviewOrderRefundUrl(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 getCancelOrderUrl = (orderId) => {
     return `https://billing.leaflow.cloud/api/v1/orders/${encodeURIComponent(String(orderId))}/cancel`;
 };
@@ -1661,14 +1904,13 @@ export const getCancelOrderUrl = (orderId) => {
  * 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
+ * The canceled items keep their agreed amounts and discounts: credit notes reduce the issued invoice, and
+ * collected amounts return to their original payment sources, possibly asynchronously. An online
  * payment waiting for the payer is canceled with the order; one the gateway is processing is refused with
  * `BILLING_PAYMENT_PENDING` and `meta.transaction_id`. Repeating the cancellation does not refund twice.
  *
  * An accepted order is canceled by its owning service, and delivered items through subscription cancellation.
- * Refunds are quoted with the quote operation's `refund` target.
+ * Refunds are previewed with `preview-order-refund`.
  * @summary Cancel order
  */
 export const cancelOrder = async (orderId, orderCancel, options, fetchFn) => {