@leaflow/sdk 0.0.0-dev.375.gbce4ffc → 0.0.0-dev.379.g796e6e7

package/dist/billing/v1/generated/schemas.zod.js

@@ -11,6 +11,8 @@ import { BillingAccountCreate } from "./validators/billingAccountCreate.zod.js";
 import { BillingAccountUpdate } from "./validators/billingAccountUpdate.zod.js";
 import { CancelSubscriptionRequest } from "./validators/cancelSubscriptionRequest.zod.js";
 import { CancellationCreate } from "./validators/cancellationCreate.zod.js";
+import { CheckoutSessionConfirm } from "./validators/checkoutSessionConfirm.zod.js";
+import { CheckoutSessionCreate } from "./validators/checkoutSessionCreate.zod.js";
 import { ContactCreate } from "./validators/contactCreate.zod.js";
 import { ContactUpdate } from "./validators/contactUpdate.zod.js";
 import { OrderCancel } from "./validators/orderCancel.zod.js";
@@ -18,7 +20,6 @@ import { PayInvoiceRequest } from "./validators/payInvoiceRequest.zod.js";
 import { PayTogetherRequest } from "./validators/payTogetherRequest.zod.js";
 import { PaymentMethodSetup } from "./validators/paymentMethodSetup.zod.js";
 import { RenewRequest } from "./validators/renewRequest.zod.js";
-import { RenewalOrderRequest } from "./validators/renewalOrderRequest.zod.js";
 import { SetProjectAssignmentRequest } from "./validators/setProjectAssignmentRequest.zod.js";
 import { TopUpCreate } from "./validators/topUpCreate.zod.js";
 import { WithdrawalCreate } from "./validators/withdrawalCreate.zod.js";
@@ -412,15 +413,9 @@ export const DeletePaymentMethodParams = zod.strictObject({
 });
 /**
  * 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
@@ -433,8 +428,9 @@ export const DeletePaymentMethodParams = zod.strictObject({
  * 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 PayInvoiceParams = zod.strictObject({
@@ -447,8 +443,6 @@ export const PayInvoiceBody = PayInvoiceRequest;
  * 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
@@ -456,16 +450,9 @@ export const PayInvoiceBody = PayInvoiceRequest;
 export const PreviewInvoicePaymentParams = zod.strictObject({
     invoiceId: zod.uuid(),
 });
-export const previewInvoicePaymentQueryPromotionCodeMax = 64;
 export const previewInvoicePaymentQueryUseBalanceDefault = true;
 export const previewInvoicePaymentQueryUseCreditsDefault = true;
 export const PreviewInvoicePaymentQueryParams = zod.strictObject({
-    promotion_code: zod
-        .string()
-        .min(1)
-        .max(previewInvoicePaymentQueryPromotionCodeMax)
-        .optional()
-        .describe("As in paying; used only while the order's terms are not fixed."),
     use_balance: zod
         .boolean()
         .default(previewInvoicePaymentQueryUseBalanceDefault)
@@ -477,15 +464,13 @@ export const PreviewInvoicePaymentQueryParams = zod.strictObject({
 });
 /**
  * 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.
@@ -493,7 +478,7 @@ export const PreviewInvoicePaymentQueryParams = zod.strictObject({
  */
 export const PayTogetherBody = PayTogetherRequest;
 /**
- * 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 listInvoicesQueryPageDefault = 1;
@@ -518,9 +503,9 @@ export const ListInvoicesQueryParams = zod.strictObject({
         .optional()
         .describe("Only this account of yours; all when omitted."),
     status: zod
-        .enum(["draft", "open", "paid", "void"])
+        .enum(["open", "paid", "void"])
         .optional()
-        .describe("`draft`: not yet issued; an order's draft invoice shows base prices until it is paid, when the discount is applied and it is issued. Other drafts are visible only to operators. `open`: issued and not yet settled; a zero-total invoice is paid at once. `paid` stays paid after a refund, with the refunded part in amount_refunded. `void`: collection has stopped and any funds received have been returned. Usage not yet invoiced is not on any invoice."),
+        .describe("`open`: issued and not yet settled; a zero-total invoice is paid at once. `paid` stays paid after a refund, with the refunded part in amount_refunded. `void`: collection has stopped and any funds received have been returned. Usage not yet invoiced is not on any invoice."),
     subscription_id: zod
         .uuid()
         .optional()
@@ -529,14 +514,14 @@ export const ListInvoicesQueryParams = zod.strictObject({
     to: zod.iso.datetime({ offset: true }).optional().describe("Exclusive."),
 });
 /**
- * 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 GetInvoiceParams = zod.strictObject({
     invoiceId: zod.uuid(),
 });
 /**
- * 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 ListInvoiceItemsParams = zod.strictObject({
@@ -967,7 +952,7 @@ export const ListRenewalPricesQueryParams = zod.strictObject({
  *
  * 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
@@ -976,21 +961,6 @@ export const RenewSubscriptionParams = zod.strictObject({
     subscriptionId: zod.uuid(),
 });
 export const RenewSubscriptionBody = RenewRequest;
-/**
- * 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 CreateRenewalOrderParams = zod.strictObject({
-    subscriptionId: zod.uuid(),
-});
-export const CreateRenewalOrderBody = RenewalOrderRequest;
 /**
  * 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
@@ -1043,6 +1013,127 @@ export const ListAllowancesQueryParams = zod.strictObject({
         .optional()
         .describe("Only records of these projects. Omit for all projects and account-level records. It does not grant access to other billing accounts."),
 });
+/**
+ * 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 listCheckoutSessionsQueryPageDefault = 1;
+export const listCheckoutSessionsQueryPageMax = 2147483647;
+export const listCheckoutSessionsQueryPageSizeDefault = 50;
+export const listCheckoutSessionsQueryPageSizeMax = 200;
+export const listCheckoutSessionsQueryProjectIdsMax = 100;
+export const ListCheckoutSessionsQueryParams = zod.strictObject({
+    page: zod
+        .int()
+        .min(1)
+        .max(listCheckoutSessionsQueryPageMax)
+        .default(listCheckoutSessionsQueryPageDefault)
+        .describe("1-based page number. Defaults to 1."),
+    page_size: zod
+        .int()
+        .min(1)
+        .max(listCheckoutSessionsQueryPageSizeMax)
+        .default(listCheckoutSessionsQueryPageSizeDefault)
+        .describe("Items per page. Defaults to 50; at most 200."),
+    billing_account_id: zod
+        .int()
+        .optional()
+        .describe("Only this account of yours; all when omitted."),
+    status: zod
+        .enum(["open", "complete", "expired"])
+        .optional()
+        .describe("`open`: waiting for you to complete checkout; nothing is ordered, invoiced or reserved. `complete`: the order and its issued invoice exist; read the order for payment and delivery. `expired`: ended without an order."),
+    project_ids: zod
+        .array(zod.uuid())
+        .min(1)
+        .max(listCheckoutSessionsQueryProjectIdsMax)
+        .optional()
+        .describe("Only records of these projects. Omit for all projects and account-level records. It does not grant access to other billing accounts."),
+});
+/**
+ * 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 CreateCheckoutSessionBody = CheckoutSessionCreate;
+/**
+ * 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 GetCheckoutSessionParams = zod.strictObject({
+    checkoutSessionId: zod.uuid(),
+});
+/**
+ * What the session buys, by position. Prices and amounts are in its quote.
+ * @summary List Checkout Session items
+ */
+export const ListCheckoutSessionItemsParams = zod.strictObject({
+    checkoutSessionId: zod.uuid(),
+});
+export const listCheckoutSessionItemsQueryPageDefault = 1;
+export const listCheckoutSessionItemsQueryPageMax = 2147483647;
+export const listCheckoutSessionItemsQueryPageSizeDefault = 50;
+export const listCheckoutSessionItemsQueryPageSizeMax = 200;
+export const ListCheckoutSessionItemsQueryParams = zod.strictObject({
+    page: zod
+        .int()
+        .min(1)
+        .max(listCheckoutSessionItemsQueryPageMax)
+        .default(listCheckoutSessionItemsQueryPageDefault)
+        .describe("1-based page number. Defaults to 1."),
+    page_size: zod
+        .int()
+        .min(1)
+        .max(listCheckoutSessionItemsQueryPageSizeMax)
+        .default(listCheckoutSessionItemsQueryPageSizeDefault)
+        .describe("Items per page. Defaults to 50; at most 200."),
+});
+/**
+ * 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 GetCheckoutSessionQuoteParams = zod.strictObject({
+    checkoutSessionId: zod.uuid(),
+});
+export const getCheckoutSessionQuoteQueryPromotionCodeMax = 64;
+export const GetCheckoutSessionQuoteQueryParams = zod.strictObject({
+    promotion_code: zod.string().min(1).max(getCheckoutSessionQuoteQueryPromotionCodeMax).optional(),
+});
+/**
+ * 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 ConfirmCheckoutSessionParams = zod.strictObject({
+    checkoutSessionId: zod.uuid(),
+});
+export const ConfirmCheckoutSessionBody = CheckoutSessionConfirm;
+/**
+ * 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 ExpireCheckoutSessionParams = zod.strictObject({
+    checkoutSessionId: zod.uuid(),
+});
 /**
  * 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
@@ -1089,20 +1180,35 @@ export const ListOrdersQueryParams = zod.strictObject({
 export const GetOrderParams = zod.strictObject({
     orderId: zod.uuid(),
 });
+/**
+ * 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 PreviewOrderRefundParams = zod.strictObject({
+    orderId: zod.uuid(),
+});
+export const previewOrderRefundQueryOrderItemIdsMax = 100;
+export const PreviewOrderRefundQueryParams = zod.strictObject({
+    order_item_ids: zod
+        .array(zod.uuid())
+        .min(1)
+        .max(previewOrderRefundQueryOrderItemIdsMax)
+        .optional()
+        .describe("Only these items of the order. Omit for the whole order."),
+});
 /**
  * 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
+ * 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 CancelOrderParams = zod.strictObject({

package/dist/billing/v1/generated/validators/{quoteCancellation.zod.d.ts → cancellationPreviewRequest.zod.d.ts}

@@ -6,13 +6,14 @@
  * OpenAPI spec version: v1
  */
 import * as zod from "zod";
-export declare const quoteCancellationSubscriptionIdsMax = 50;
-export declare const QuoteCancellation: zod.ZodObject<{
+export declare const cancellationPreviewRequestSubscriptionIdsMax = 50;
+export declare const CancellationPreviewRequest: zod.ZodObject<{
+    billing_account_id: zod.ZodInt;
     subscription_ids: zod.ZodArray<zod.ZodUUID>;
     mode: zod.ZodEnum<{
         immediate: "immediate";
         period_end: "period_end";
     }>;
 }, zod.z.core.$strict>;
-export type QuoteCancellation = zod.input<typeof QuoteCancellation>;
-export type QuoteCancellationOutput = zod.output<typeof QuoteCancellation>;
+export type CancellationPreviewRequest = zod.input<typeof CancellationPreviewRequest>;
+export type CancellationPreviewRequestOutput = zod.output<typeof CancellationPreviewRequest>;

package/dist/billing/v1/generated/validators/cancellationPreviewRequest.zod.js

@@ -0,0 +1,24 @@
+/**
+ * Generated by orval 🍺
+ * Do not edit manually.
+ * Leaflow Billing API
+ * Products, prices, orders, subscriptions and account billing. Financial operations require an account access token and billing-account authorization. Public catalogue operations declare no security requirement.
+ * OpenAPI spec version: v1
+ */
+import * as zod from "zod";
+import { CancellationPolicy } from "./cancellationPolicy.zod.js";
+export const cancellationPreviewRequestSubscriptionIdsMax = 50;
+export const CancellationPreviewRequest = zod
+    .strictObject({
+    billing_account_id: zod
+        .int()
+        .min(1)
+        .describe("A billing account you own that currently pays for every subscription."),
+    subscription_ids: zod
+        .array(zod.uuid())
+        .min(1)
+        .max(cancellationPreviewRequestSubscriptionIdsMax)
+        .describe("The subscriptions to end together, all of one service, including every subscription released with a resource."),
+    mode: CancellationPolicy,
+})
+    .describe("What ending these subscriptions together would return, for one mode; preview `immediate` and `period_end` separately to compare. Refused with 409 `BILLING_SUBSCRIPTION_OPERATION_PENDING` when a subscription is already being canceled (`meta.cancellation_id`), is being reclaimed (`meta.reason` `reclaim_requested`) or has a paid change waiting to switch (`meta.order_id`).");

package/dist/billing/v1/generated/validators/cancellationRefundPreviewItem.zod.js

@@ -32,4 +32,4 @@ export const CancellationRefundPreviewItem = zod
     tax_amount: Money,
     forfeited_amount: Money,
 })
-    .describe("One subscription of the quoted cancellation.");
+    .describe("One subscription of the previewed cancellation.");

package/dist/billing/v1/generated/validators/checkoutMode.zod.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Generated by orval 🍺
+ * Do not edit manually.
+ * Leaflow Billing API
+ * Products, prices, orders, subscriptions and account billing. Financial operations require an account access token and billing-account authorization. Public catalogue operations declare no security requirement.
+ * OpenAPI spec version: v1
+ */
+import * as zod from "zod";
+export declare const CheckoutMode: zod.ZodEnum<{
+    automatic: "automatic";
+    deferred: "deferred";
+}>;
+export type CheckoutMode = zod.input<typeof CheckoutMode>;
+export type CheckoutModeOutput = zod.output<typeof CheckoutMode>;

package/dist/billing/v1/generated/validators/checkoutMode.zod.js

@@ -0,0 +1,11 @@
+/**
+ * Generated by orval 🍺
+ * Do not edit manually.
+ * Leaflow Billing API
+ * Products, prices, orders, subscriptions and account billing. Financial operations require an account access token and billing-account authorization. Public catalogue operations declare no security requirement.
+ * OpenAPI spec version: v1
+ */
+import * as zod from "zod";
+export const CheckoutMode = zod
+    .enum(["automatic", "deferred"])
+    .describe("automatic completes checkout with the purchase: the best applicable account discount is applied, and the\norder is created with its invoice issued and paid from eligible credit grants and available balance.\nInsufficient funds fail the purchase with HTTP 422 BILLING_INSUFFICIENT_FUNDS; no Billing order, charge or\ndiscount redemption is committed.\ndeferred creates an open Billing Checkout Session and charges nothing, even for a zero total. The customer\ncompletes it through Billing, where a promotion code can be applied, and then pays the issued invoice; a\nsession not completed by its deadline expires.");

package/dist/billing/v1/generated/validators/checkoutOptions.zod.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Generated by orval 🍺
+ * Do not edit manually.
+ * Leaflow Billing API
+ * Products, prices, orders, subscriptions and account billing. Financial operations require an account access token and billing-account authorization. Public catalogue operations declare no security requirement.
+ * OpenAPI spec version: v1
+ */
+import * as zod from "zod";
+export declare const checkoutOptionsModeDefault = "automatic";
+export declare const checkoutOptionsExpectedAmountTwoRegExp: RegExp;
+export declare const checkoutOptionsReturnUrlMax = 2048;
+export declare const CheckoutOptions: zod.ZodObject<{
+    mode: zod.ZodDefault<zod.ZodEnum<{
+        automatic: "automatic";
+        deferred: "deferred";
+    }>>;
+    expected_amount: zod.ZodOptional<zod.ZodIntersection<zod.ZodString, zod.ZodString>>;
+    return_url: zod.ZodOptional<zod.ZodURL>;
+}, zod.z.core.$strict>;
+export type CheckoutOptions = zod.input<typeof CheckoutOptions>;
+export type CheckoutOptionsOutput = zod.output<typeof CheckoutOptions>;

package/dist/billing/v1/generated/validators/checkoutOptions.zod.js

@@ -0,0 +1,26 @@
+/**
+ * Generated by orval 🍺
+ * Do not edit manually.
+ * Leaflow Billing API
+ * Products, prices, orders, subscriptions and account billing. Financial operations require an account access token and billing-account authorization. Public catalogue operations declare no security requirement.
+ * OpenAPI spec version: v1
+ */
+import * as zod from "zod";
+import { CheckoutMode } from "./checkoutMode.zod.js";
+import { Money } from "./money.zod.js";
+export const checkoutOptionsModeDefault = `automatic`;
+export const checkoutOptionsExpectedAmountTwoRegExp = new RegExp("^[0-9]{1,15}([.][0-9]{1,10})?$");
+export const checkoutOptionsReturnUrlMax = 2048;
+export const CheckoutOptions = zod
+    .strictObject({
+    mode: CheckoutMode.default(checkoutOptionsModeDefault),
+    expected_amount: Money.and(zod.string().regex(checkoutOptionsExpectedAmountTwoRegExp))
+        .optional()
+        .describe("Expected invoice total after discounts and tax, before applying credit grants or balance.\nA different total fails with BILLING_AMOUNT_CHANGED without charging or reserving a discount.\nAccepted only in automatic mode; with deferred it is refused with HTTP 400. For deferred\ncheckout, give the expected amount when completing it through Billing."),
+    return_url: zod
+        .url()
+        .max(checkoutOptionsReturnUrlMax)
+        .optional()
+        .describe("Where the client goes after the customer finishes a deferred checkout. Any absolute URI with a\nscheme, including mobile and desktop application schemes. Billing stores it without checking the\ntarget; each client validates its own."),
+})
+    .describe("Shared checkout choices for a product purchase. The service may set them or forward its client's\nchoices unchanged; it does not need to read them, and Billing validates them. Omitting this object or\nmode selects automatic checkout. Each purchase creates its own Checkout Session. Promotion codes are supplied\nonly to Billing. A service may retain a failed creation record when Billing refuses a purchase; no\ninfrastructure is created for that refusal.");

package/dist/billing/v1/generated/validators/checkoutSession.zod.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Generated by orval 🍺
+ * Do not edit manually.
+ * Leaflow Billing API
+ * Products, prices, orders, subscriptions and account billing. Financial operations require an account access token and billing-account authorization. Public catalogue operations declare no security requirement.
+ * OpenAPI spec version: v1
+ */
+import * as zod from "zod";
+export declare const CheckoutSession: zod.ZodObject<{
+    id: zod.ZodUUID;
+    product_id: zod.ZodString;
+    billing_account_id: zod.ZodInt;
+    account: zod.ZodObject<{
+        id: zod.ZodInt;
+        name: zod.ZodString;
+        currency: zod.ZodString;
+    }, zod.z.core.$strict>;
+    project_id: zod.ZodNullable<zod.ZodUUID>;
+    project: zod.ZodUnion<readonly [zod.ZodObject<{
+        id: zod.ZodUUID;
+        name: zod.ZodString;
+    }, zod.z.core.$strict>, zod.ZodNull]>;
+    type: zod.ZodEnum<{
+        new: "new";
+        renew: "renew";
+        modify: "modify";
+    }>;
+    change_effective: zod.ZodEnum<{
+        none: "none";
+        immediate: "immediate";
+        period_end: "period_end";
+    }>;
+    status: zod.ZodEnum<{
+        expired: "expired";
+        open: "open";
+        complete: "complete";
+    }>;
+    currency: zod.ZodString;
+    checkout: zod.ZodObject<{
+        mode: zod.ZodDefault<zod.ZodEnum<{
+            automatic: "automatic";
+            deferred: "deferred";
+        }>>;
+        expected_amount: zod.ZodOptional<zod.ZodIntersection<zod.ZodString, zod.ZodString>>;
+        return_url: zod.ZodOptional<zod.ZodURL>;
+    }, zod.z.core.$strict>;
+    expires_at: zod.z.ZodISODateTime;
+    created_at: zod.z.ZodISODateTime;
+    completed_at: zod.ZodNullable<zod.z.ZodISODateTime>;
+    expired_at: zod.ZodNullable<zod.z.ZodISODateTime>;
+    order_id: zod.ZodNullable<zod.ZodUUID>;
+}, zod.z.core.$strict>;
+export type CheckoutSession = zod.input<typeof CheckoutSession>;
+export type CheckoutSessionOutput = zod.output<typeof CheckoutSession>;

package/dist/billing/v1/generated/validators/checkoutSession.zod.js

@@ -0,0 +1,47 @@
+/**
+ * Generated by orval 🍺
+ * Do not edit manually.
+ * Leaflow Billing API
+ * Products, prices, orders, subscriptions and account billing. Financial operations require an account access token and billing-account authorization. Public catalogue operations declare no security requirement.
+ * OpenAPI spec version: v1
+ */
+import * as zod from "zod";
+import { AccountIdentity } from "./accountIdentity.zod.js";
+import { CheckoutOptions } from "./checkoutOptions.zod.js";
+import { CheckoutSessionStatus } from "./checkoutSessionStatus.zod.js";
+import { NamedIdentity } from "./namedIdentity.zod.js";
+import { ProductID } from "./productID.zod.js";
+export const CheckoutSession = zod
+    .strictObject({
+    id: zod.uuid(),
+    product_id: ProductID,
+    billing_account_id: zod.int(),
+    account: AccountIdentity,
+    project_id: zod
+        .uuid()
+        .nullable()
+        .describe("The project the purchase is for. Null for an account-level purchase, such as a membership."),
+    project: zod
+        .union([NamedIdentity, zod.null()])
+        .describe("The project and its current name. Null for an account-level purchase or when the project cannot be read; `project_id` still identifies it."),
+    type: zod
+        .enum(["new", "renew", "modify"])
+        .describe("`new` buys, `renew` extends a licensed subscription, `modify` changes a subscription's configuration or billing terms."),
+    change_effective: zod
+        .enum(["none", "immediate", "period_end"])
+        .describe("When a change takes effect, as on the order it creates; `none` for anything that is not a change."),
+    status: CheckoutSessionStatus,
+    currency: zod.string(),
+    checkout: CheckoutOptions.describe("The checkout choices as the purchase gave them. Billing does not check `return_url`; validate it before navigating."),
+    expires_at: zod.iso
+        .datetime({ offset: true })
+        .describe("When an open session expires. The order a complete session created has its own payment deadline."),
+    created_at: zod.iso.datetime({ offset: true }),
+    completed_at: zod.iso.datetime({ offset: true }).nullable(),
+    expired_at: zod.iso.datetime({ offset: true }).nullable(),
+    order_id: zod
+        .uuid()
+        .nullable()
+        .describe("The order created when the session completed. Null otherwise."),
+})
+    .describe("A purchase waiting for you to complete checkout. Completing it applies the discount and creates the order with its invoice issued; the order carries the session's ID.");

package/dist/billing/v1/generated/validators/checkoutSessionConfirm.zod.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Generated by orval 🍺
+ * Do not edit manually.
+ * Leaflow Billing API
+ * Products, prices, orders, subscriptions and account billing. Financial operations require an account access token and billing-account authorization. Public catalogue operations declare no security requirement.
+ * OpenAPI spec version: v1
+ */
+import * as zod from "zod";
+export declare const checkoutSessionConfirmPromotionCodeMax = 64;
+export declare const checkoutSessionConfirmExpectedAmountTwoRegExp: RegExp;
+export declare const CheckoutSessionConfirm: zod.ZodObject<{
+    promotion_code: zod.ZodOptional<zod.ZodString>;
+    expected_amount: zod.ZodIntersection<zod.ZodString, zod.ZodString>;
+    proration_date: zod.ZodOptional<zod.z.ZodISODateTime>;
+}, zod.z.core.$strict>;
+export type CheckoutSessionConfirm = zod.input<typeof CheckoutSessionConfirm>;
+export type CheckoutSessionConfirmOutput = zod.output<typeof CheckoutSessionConfirm>;

package/dist/billing/v1/generated/validators/checkoutSessionConfirm.zod.js

@@ -0,0 +1,24 @@
+/**
+ * Generated by orval 🍺
+ * Do not edit manually.
+ * Leaflow Billing API
+ * Products, prices, orders, subscriptions and account billing. Financial operations require an account access token and billing-account authorization. Public catalogue operations declare no security requirement.
+ * OpenAPI spec version: v1
+ */
+import * as zod from "zod";
+import { Money } from "./money.zod.js";
+export const checkoutSessionConfirmPromotionCodeMax = 64;
+export const checkoutSessionConfirmExpectedAmountTwoRegExp = new RegExp("^[0-9]{1,15}([.][0-9]{1,10})?$");
+export const CheckoutSessionConfirm = zod.strictObject({
+    promotion_code: zod
+        .string()
+        .min(1)
+        .max(checkoutSessionConfirmPromotionCodeMax)
+        .optional()
+        .describe("As quoted. Omit to apply the best applicable account discount."),
+    expected_amount: Money.and(zod.string().regex(checkoutSessionConfirmExpectedAmountTwoRegExp)).describe("The quote's `total`, after discounts and tax and before credit grants or balance."),
+    proration_date: zod.iso
+        .datetime({ offset: true })
+        .optional()
+        .describe("Immediate changes only. The quote's `proration_date`; it must be a whole second, not in the future and at most 10 minutes old, otherwise the request is refused with `BILLING_CHANGE_INVALID`. Defaults to the time of the request."),
+});

package/dist/billing/v1/generated/validators/{renewalOrderRequest.zod.d.ts → checkoutSessionCreate.zod.d.ts}

@@ -6,9 +6,10 @@
  * OpenAPI spec version: v1
  */
 import * as zod from "zod";
-export declare const renewalOrderRequestPeriodsDefault = 1;
-export declare const RenewalOrderRequest: zod.ZodObject<{
-    order_id: zod.ZodUUID;
+export declare const checkoutSessionCreatePeriodsDefault = 1;
+export declare const CheckoutSessionCreate: zod.ZodObject<{
+    checkout_session_id: zod.ZodUUID;
+    subscription_id: zod.ZodUUID;
     periods: zod.ZodDefault<zod.ZodInt>;
     interval_count: zod.ZodOptional<zod.ZodInt>;
     interval: zod.ZodOptional<zod.ZodEnum<{
@@ -21,5 +22,5 @@ export declare const RenewalOrderRequest: zod.ZodObject<{
         period_end: "period_end";
     }>>;
 }, zod.z.core.$strict>;
-export type RenewalOrderRequest = zod.input<typeof RenewalOrderRequest>;
-export type RenewalOrderRequestOutput = zod.output<typeof RenewalOrderRequest>;
+export type CheckoutSessionCreate = zod.input<typeof CheckoutSessionCreate>;
+export type CheckoutSessionCreateOutput = zod.output<typeof CheckoutSessionCreate>;