@peable.to/contracts 0.4.0 → 1.1.0

package/dist/cjs/resources/checkout/checkoutSessions.js

@@ -0,0 +1,582 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkoutSessionRoutes = exports.expireCheckoutSessionTestHelperParams = exports.confirmCheckoutSessionPublicParams = exports.updateCheckoutSessionPublicParams = exports.listCheckoutSessionLineItemsQuery = exports.listCheckoutSessionsQuery = exports.expireCheckoutSessionParams = exports.updateCheckoutSessionParams = exports.createCheckoutSessionParams = exports.sessionLineItemParams = exports.checkoutSessionPublicSchema = exports.checkoutSessionSchema = void 0;
+const zod_1 = require("zod");
+const catalog_1 = require("../../vocabulary/catalog");
+const payments_1 = require("../../vocabulary/payments");
+const billing_1 = require("../catalog/billing");
+const objects_1 = require("../../common/objects");
+const envelopes_1 = require("../../common/envelopes");
+const objects_2 = require("../../common/objects");
+const params_1 = require("../../common/params");
+const primitives_1 = require("../../common/primitives");
+const route_1 = require("../../route");
+const checkout_1 = require("../../vocabulary/checkout");
+const shared_1 = require("./shared");
+/**
+ * Checkout Sessions (`cs_…`, Orbit Phase 3) — Stripe Checkout's session model:
+ * a session is an ORDER (line items, discounts, tax, what to collect from the
+ * payer) that a payer completes on Peable's hosted or embedded checkout. The
+ * PaymentIntent (or SetupIntent) is created when the payer confirms, with the
+ * amount the session computed, and linked. Amounts are base-unit strings.
+ */
+const sessionFields = {
+    id: zod_1.z.string(),
+    object: zod_1.z.literal('checkout_session'),
+    livemode: primitives_1.livemode,
+    mode: zod_1.z.enum(checkout_1.CHECKOUT_SESSION_MODES),
+    status: zod_1.z.enum(checkout_1.CHECKOUT_SESSION_STATUSES),
+    payment_status: zod_1.z.enum(checkout_1.CHECKOUT_PAYMENT_STATUSES),
+    ui_mode: zod_1.z.enum(checkout_1.CHECKOUT_UI_MODES),
+    locale: zod_1.z
+        .enum(checkout_1.CHECKOUT_LOCALES)
+        .nullable()
+        .describe("The language checkout renders in; `null` follows the payer's browser."),
+    submit_type: zod_1.z.enum(checkout_1.CHECKOUT_SUBMIT_TYPES),
+    currency: primitives_1.currency,
+    rail: shared_1.railSchema,
+    network: primitives_1.network.nullable().describe('FairCoin rail only; `null` on a card session.'),
+    amount_subtotal: primitives_1.amount,
+    amount_total: primitives_1.amount,
+    total_details: shared_1.checkoutTotalDetailsSchema,
+    allow_promotion_codes: zod_1.z.boolean(),
+    automatic_tax: shared_1.checkoutAutomaticTaxSchema,
+    ...shared_1.collectionResponseFields,
+    shipping_details: shared_1.checkoutShippingDetailsSchema.nullable(),
+    consent: shared_1.checkoutConsentSchema.nullable(),
+    expires_at: primitives_1.unixSeconds,
+};
+/** The merchant/SDK-facing session — Stripe's Checkout Session. */
+exports.checkoutSessionSchema = (0, objects_2.defineObject)('checkout_session', 'CheckoutSession', zod_1.z
+    .object({
+    ...sessionFields,
+    payment_method_types: zod_1.z.array(shared_1.railSchema),
+    discounts: zod_1.z.array(shared_1.checkoutDiscountSchema),
+    customer: (0, objects_2.expandable)('customer', '`cus_…` (expandable) — given on create, or created at completion.').nullable(),
+    customer_email: zod_1.z.string().nullable(),
+    customer_creation: zod_1.z.enum(checkout_1.CHECKOUT_CUSTOMER_CREATIONS),
+    customer_details: shared_1.checkoutCustomerDetailsSchema.nullable(),
+    payment_intent: (0, objects_2.expandable)('payment_intent', 'The payment this session created (`pi_…`, expandable) once the payer confirmed; `null` before, and always in `setup` mode.').nullable(),
+    setup_intent: (0, objects_2.expandable)('setup_intent', '`setup` mode: the SetupIntent (`seti_…`, expandable) once confirmed.').nullable(),
+    connected_account: (0, objects_2.expandable)('connected_account', 'The seller an on-behalf payment pays (`ca_…`, expandable).').nullable(),
+    payment_link: zod_1.z
+        .string()
+        .nullable()
+        .describe('The payment link this session was created from (`link_…`), if any.'),
+    client_reference_id: zod_1.z.string().nullable(),
+    metadata: primitives_1.metadata,
+    success_url: zod_1.z
+        .string()
+        .nullable()
+        .describe('With `{CHECKOUT_SESSION_ID}` as given; checkout substitutes it.'),
+    cancel_url: zod_1.z.string().nullable(),
+    url: zod_1.z
+        .string()
+        .nullable()
+        .describe('Hosted mode: the URL to send the payer to. `null` in embedded mode.'),
+    client_secret: zod_1.z
+        .string()
+        .nullable()
+        .describe('Embedded mode: what `PeableCheckout.mountCheckout` takes. `null` in hosted mode.'),
+    created: primitives_1.unixSeconds,
+})
+    .strict(), {
+    examples: [
+        {
+            id: 'cs_0193b8f2c1a87d3e9f4a',
+            object: 'checkout_session',
+            livemode: false,
+            mode: 'payment',
+            status: 'open',
+            payment_status: 'unpaid',
+            ui_mode: 'hosted',
+            locale: null,
+            submit_type: 'auto',
+            currency: 'EUR',
+            rail: 'card',
+            network: null,
+            payment_method_types: ['card'],
+            amount_subtotal: '1999',
+            amount_total: '1999',
+            total_details: { amount_discount: '0', amount_tax: '0', amount_shipping: '0' },
+            discounts: [],
+            allow_promotion_codes: false,
+            automatic_tax: { enabled: false, status: null },
+            customer: null,
+            customer_email: 'jenny@example.com',
+            customer_creation: 'if_required',
+            customer_details: null,
+            billing_address_collection: 'auto',
+            shipping_address_collection: null,
+            shipping_details: null,
+            phone_number_collection: { enabled: false },
+            tax_id_collection: { enabled: false },
+            custom_fields: [],
+            consent_collection: null,
+            consent: null,
+            payment_intent: null,
+            setup_intent: null,
+            connected_account: null,
+            payment_link: null,
+            client_reference_id: null,
+            metadata: {},
+            success_url: 'https://example.com/thanks?session={CHECKOUT_SESSION_ID}',
+            cancel_url: null,
+            url: 'https://checkout.peable.to/c/cs_0193b8f2c1a87d3e9f4a#cs=cs_0193b8f2c1a87d3e9f4a_secret_x',
+            client_secret: null,
+            expires_at: 1793836800,
+            created: 1793750400,
+        },
+    ],
+});
+/**
+ * What the hosted/embedded checkout loads, authorized by the session's
+ * `client_secret` (or, for a session wrapping a payment, that payment's). No
+ * metadata, no client reference, no internal ids.
+ */
+exports.checkoutSessionPublicSchema = (0, objects_2.defineComponent)('CheckoutSessionPublic', zod_1.z
+    .object({
+    ...sessionFields,
+    line_items: zod_1.z.array(shared_1.checkoutLineItemSchema),
+    discount: zod_1.z
+        .object({
+        promotion_code: zod_1.z.string().nullable().describe('The code the payer typed.'),
+        coupon_name: zod_1.z.string().nullable(),
+        amount_off: primitives_1.amount.nullable(),
+        percent_off: zod_1.z.number().nullable(),
+    })
+        .strict()
+        .nullable()
+        .describe('The discount applied, as the payer sees it.'),
+    customer_details: shared_1.checkoutCustomerDetailsSchema.describe('Prefilled from `customer_email` / the customer; then what the payer entered.'),
+    customer_email_locked: zod_1.z
+        .boolean()
+        .describe('Whether the email is fixed by the merchant (a `customer` or `customer_email`).'),
+    terms_of_service_url: zod_1.z
+        .string()
+        .nullable()
+        .describe("The merchant's terms URL when `consent_collection.terms_of_service` is required."),
+    payment_intent: (0, objects_1.embedded)('payment_intent')
+        .nullable()
+        .describe("The payment the payer confirmed — with its `client_secret`, the payer's capability."),
+    setup_intent: zod_1.z
+        .object({
+        id: zod_1.z.string(),
+        client_secret: zod_1.z.string(),
+        status: zod_1.z.enum(payments_1.SETUP_INTENT_STATUSES),
+    })
+        .strict()
+        .nullable()
+        .describe('`setup` mode: the SetupIntent id and client secret, once confirmed.'),
+    success_url: zod_1.z
+        .string()
+        .nullable()
+        .describe('`success_url` with `{CHECKOUT_SESSION_ID}` substituted; only once `complete`.'),
+    cancel_url: zod_1.z.string().nullable().describe('Shown as "Back to <merchant>" before payment.'),
+    confirmation_message: zod_1.z
+        .string()
+        .nullable()
+        .describe("A payment link's hosted confirmation, shown once `complete`."),
+    merchant: shared_1.merchantDisplaySchema,
+    branding: shared_1.checkoutBrandingSchema,
+    publishable_key: zod_1.z
+        .string()
+        .nullable()
+        .describe("The card provider's PUBLIC key for this session's mode, so the payment fields can mount before the payment exists. `null` on FairCoin."),
+    billing_quote: billing_1.billingFaircoinFxQuoteSchema
+        .optional()
+        .describe('FairCoin billing invoices: the frozen USD price and FAIR settlement quote.'),
+})
+    .strict());
+// ---- Merchant create/update ---------------------------------------------------
+const productDataParams = zod_1.z
+    .object({
+    name: zod_1.z.string().trim().min(1).max(catalog_1.CATALOG_LIMITS.productNameMax),
+    description: zod_1.z.string().min(1).max(catalog_1.CATALOG_LIMITS.productDescriptionMax).optional(),
+    images: zod_1.z
+        .array(zod_1.z
+        .string()
+        .max(catalog_1.CATALOG_LIMITS.urlMax)
+        .regex(/^https:\/\/\S+$/, 'must be an https URL'))
+        .max(8)
+        .optional(),
+    tax_code: zod_1.z
+        .string()
+        .regex(/^txcd_[0-9]{8}$/, 'is not a Peable Tax code (GET /v1/tax/codes lists them)')
+        .optional()
+        .describe('A Peable Tax code (`GET /v1/tax/codes`).'),
+})
+    .strict();
+const priceDataParams = zod_1.z
+    .object({
+    currency: primitives_1.currency,
+    unit_amount: shared_1.amountParam,
+    product: shared_1.checkoutIdParam.optional(),
+    product_data: productDataParams.optional(),
+    recurring: zod_1.z
+        .object({
+        interval: zod_1.z.enum(catalog_1.RECURRING_INTERVALS),
+        interval_count: zod_1.z.number().int().min(1).max(1095).optional(),
+    })
+        .strict()
+        .optional(),
+    tax_behavior: zod_1.z.enum(catalog_1.PRICE_TAX_BEHAVIORS).optional(),
+})
+    .strict()
+    .superRefine((data, ctx) => {
+    if ((data.product === undefined) === (data.product_data === undefined)) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['product'],
+            message: 'exactly one of product and product_data',
+        });
+    }
+});
+/** One `line_items[]` entry of a session: exactly one of `price` and `price_data`. */
+exports.sessionLineItemParams = zod_1.z
+    .object({
+    price: shared_1.checkoutIdParam.optional(),
+    price_data: priceDataParams.optional(),
+    quantity: shared_1.quantityParam,
+    adjustable_quantity: shared_1.adjustableQuantityParam.optional(),
+})
+    .strict()
+    .superRefine((line, ctx) => {
+    if ((line.price === undefined) === (line.price_data === undefined)) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['price'],
+            message: 'exactly one of price and price_data',
+        });
+    }
+    (0, shared_1.adjustableIssues)(line.quantity, line.adjustable_quantity, ctx);
+});
+const discountParam = zod_1.z.union([
+    zod_1.z.object({ coupon: shared_1.checkoutIdParam }).strict(),
+    zod_1.z.object({ promotion_code: shared_1.checkoutIdParam }).strict(),
+]);
+exports.createCheckoutSessionParams = zod_1.z
+    .object({
+    mode: zod_1.z.enum(checkout_1.CHECKOUT_SESSION_MODES).optional().describe('Default `payment`.'),
+    line_items: zod_1.z
+        .array(exports.sessionLineItemParams)
+        .min(1)
+        .max(checkout_1.CHECKOUT_LIMITS.lineItemsMax)
+        .optional()
+        .describe('Required in `payment` and `subscription` mode; refused in `setup` mode.'),
+    currency: primitives_1.currency
+        .optional()
+        .describe('`setup` mode: the currency of the method being saved (card rail only).'),
+    discounts: zod_1.z
+        .array(discountParam)
+        .max(1)
+        .optional()
+        .describe('At most one; mutually exclusive with `allow_promotion_codes`.'),
+    allow_promotion_codes: zod_1.z.boolean().optional(),
+    customer: shared_1.checkoutIdParam
+        .optional()
+        .describe('`cus_…`; mutually exclusive with `customer_email`.'),
+    customer_email: shared_1.checkoutEmailParam.optional(),
+    customer_creation: zod_1.z
+        .enum(checkout_1.CHECKOUT_CUSTOMER_CREATIONS)
+        .optional()
+        .describe('Default `if_required` (a customer is created only when something needs one).'),
+    ...shared_1.collectionParams,
+    automatic_tax: zod_1.z.object({ enabled: zod_1.z.boolean() }).strict().optional(),
+    payment_method_types: zod_1.z
+        .array(zod_1.z.enum(['card', 'faircoin']))
+        .min(1)
+        .max(1)
+        .optional()
+        .describe("`['card']` or `['faircoin']` — the rail the line items' currency allows."),
+    locale: shared_1.localeParam.optional(),
+    ui_mode: zod_1.z.enum(checkout_1.CHECKOUT_UI_MODES).optional(),
+    success_url: shared_1.redirectUrlParam
+        .optional()
+        .describe('Required in hosted mode; may carry `{CHECKOUT_SESSION_ID}`.'),
+    cancel_url: shared_1.redirectUrlParam
+        .optional()
+        .describe('Hosted mode only: the "Back to merchant" link.'),
+    expires_at: zod_1.z
+        .number()
+        .int()
+        .positive()
+        .optional()
+        .describe('Unix seconds, 30 minutes to 24 hours from now. Default 24 hours.'),
+    client_reference_id: zod_1.z.string().min(1).max(checkout_1.CHECKOUT_LIMITS.clientReferenceIdMax).optional(),
+    metadata: params_1.metadataCreateParam.optional(),
+    submit_type: zod_1.z.enum(checkout_1.CHECKOUT_SUBMIT_TYPES).optional(),
+    connected_account: shared_1.checkoutIdParam
+        .optional()
+        .describe('Pay this seller (`ca_…`) rather than the merchant (ADR 0012); FairCoin only.'),
+    expand: params_1.expandParam.optional(),
+})
+    .strict()
+    .superRefine((body, ctx) => {
+    const issue = (path, message) => ctx.addIssue({ code: 'custom', path: [path], message });
+    const mode = body.mode ?? 'payment';
+    if (mode === 'setup') {
+        if (body.line_items)
+            issue('line_items', 'a setup session has no line items');
+        if (body.discounts || body.allow_promotion_codes) {
+            issue('discounts', 'a setup session takes no discounts');
+        }
+        if (body.automatic_tax?.enabled)
+            issue('automatic_tax', 'a setup session has no tax');
+        if (!body.currency)
+            issue('currency', 'a setup session needs a currency');
+    }
+    else {
+        if (!body.line_items)
+            issue('line_items', `line_items is required in ${mode} mode`);
+        if (body.currency !== undefined) {
+            issue('currency', 'the currency of a priced session is its line items’');
+        }
+    }
+    if (body.customer !== undefined && body.customer_email !== undefined) {
+        issue('customer_email', 'customer and customer_email are mutually exclusive');
+    }
+    if (body.discounts && body.allow_promotion_codes) {
+        issue('allow_promotion_codes', 'discounts and allow_promotion_codes are mutually exclusive');
+    }
+    const ui = body.ui_mode ?? 'hosted';
+    if (ui === 'hosted' && body.success_url === undefined) {
+        issue('success_url', 'success_url is required in hosted mode');
+    }
+    if (ui === 'embedded' && body.cancel_url !== undefined) {
+        issue('cancel_url', 'an embedded session has no cancel_url; the page around it is yours');
+    }
+    if (body.submit_type !== undefined && mode !== 'payment') {
+        issue('submit_type', 'submit_type is for payment mode');
+    }
+});
+/** `POST /v1/checkout_sessions/{id}` — the merchant's `metadata`, as a patch. */
+exports.updateCheckoutSessionParams = zod_1.z
+    .object({ metadata: params_1.metadataUpdateParam.optional(), expand: params_1.expandParam.optional() })
+    .strict();
+exports.expireCheckoutSessionParams = zod_1.z.object({ expand: params_1.expandParam.optional() }).strict();
+exports.listCheckoutSessionsQuery = (0, params_1.listQuery)({
+    payment_intent: shared_1.checkoutIdParam.optional().describe('Sessions that created this payment.'),
+    payment_link: shared_1.checkoutIdParam.optional().describe('Sessions started from this link.'),
+    customer: shared_1.checkoutIdParam.optional(),
+    status: zod_1.z.enum(checkout_1.CHECKOUT_SESSION_STATUSES).optional(),
+});
+/** A session's lines, in their order; `created` does not apply to them. */
+exports.listCheckoutSessionLineItemsQuery = (0, params_1.listQuery)({});
+// ---- Payer side ------------------------------------------------------------------
+const payerAddressParams = zod_1.z
+    .object({
+    line1: zod_1.z.string().trim().min(1).max(200).optional(),
+    line2: zod_1.z.string().trim().min(1).max(200).optional(),
+    city: zod_1.z.string().trim().min(1).max(200).optional(),
+    state: zod_1.z.string().trim().min(1).max(100).optional(),
+    postal_code: zod_1.z.string().trim().min(1).max(20).optional(),
+    country: shared_1.countryCodeParam.optional(),
+})
+    .strict();
+/** `POST /v1/checkout_sessions/{id}/public` — what the payer changes before confirming. */
+exports.updateCheckoutSessionPublicParams = zod_1.z
+    .object({
+    line_items: zod_1.z
+        .array(zod_1.z
+        .object({
+        id: shared_1.checkoutIdParam,
+        quantity: zod_1.z.number().int().min(0).max(checkout_1.CHECKOUT_LIMITS.quantityMax),
+    })
+        .strict())
+        .max(checkout_1.CHECKOUT_LIMITS.lineItemsMax)
+        .optional()
+        .describe("Adjust a line's quantity, within its `adjustable_quantity` bounds."),
+    promotion_code: zod_1.z
+        .union([zod_1.z.literal(''), zod_1.z.string().trim().min(1).max(catalog_1.CATALOG_LIMITS.promotionCodeMax)])
+        .optional()
+        .describe('A code to redeem (`allow_promotion_codes`), or `""` to remove the one applied.'),
+    customer_details: zod_1.z
+        .object({
+        email: shared_1.checkoutEmailParam.optional(),
+        name: zod_1.z.string().trim().min(1).max(200).optional(),
+        phone: zod_1.z
+            .string()
+            .trim()
+            .regex(/^\+?[0-9 ()-]{5,25}$/, 'must be a phone number')
+            .optional(),
+        address: payerAddressParams.optional(),
+        tax_ids: zod_1.z
+            .array(zod_1.z
+            .object({
+            type: zod_1.z.enum(checkout_1.CHECKOUT_TAX_ID_TYPES),
+            value: zod_1.z
+                .string()
+                .trim()
+                .regex(/^[A-Za-z0-9 .-]{2,30}$/, 'must be a tax id'),
+        })
+            .strict())
+            .max(1)
+            .optional(),
+    })
+        .strict()
+        .optional(),
+    shipping_details: zod_1.z
+        .object({ name: zod_1.z.string().trim().min(1).max(200), address: payerAddressParams })
+        .strict()
+        .nullable()
+        .optional(),
+    custom_fields: zod_1.z
+        .array(zod_1.z.object({ key: zod_1.z.string().min(1).max(200), value: zod_1.z.string().max(255) }).strict())
+        .max(checkout_1.CHECKOUT_LIMITS.customFieldsMax)
+        .optional()
+        .describe("By `key`: the payer's value for each custom field."),
+    consent: zod_1.z
+        .object({ terms_of_service: zod_1.z.literal('accepted').optional() })
+        .strict()
+        .optional(),
+})
+    .strict();
+/** `POST /v1/checkout_sessions/{id}/public/confirm` takes nothing: the order is the session's. */
+exports.confirmCheckoutSessionPublicParams = zod_1.z.object({}).strict();
+/** `POST /v1/test_helpers/checkout_sessions/{id}/expire` takes nothing. */
+exports.expireCheckoutSessionTestHelperParams = zod_1.z.object({}).strict();
+const sessionId = { id: 'The Checkout Session (`cs_…`).' };
+const payerAuth = "Authorized by the session's `client_secret` (or, for a session wrapping a payment, that payment's) in the `X-Peable-Client-Secret` header — never a URL. Unauthenticated and rate-limited; the answer is `Cache-Control: no-store`.";
+exports.checkoutSessionRoutes = [
+    (0, route_1.defineRoute)({
+        operationId: 'createCheckoutSession',
+        method: 'post',
+        path: '/v1/checkout_sessions',
+        tag: 'Checkout Sessions',
+        summary: 'Create a Checkout Session',
+        auth: 'service',
+        scope: 'payments:write',
+        idempotent: true,
+        body: exports.createCheckoutSessionParams,
+        response: exports.checkoutSessionSchema,
+        status: 201,
+        sdk: 'checkout.sessions.create',
+        expandable: 'checkout_session',
+    }),
+    (0, route_1.defineRoute)({
+        operationId: 'listCheckoutSessions',
+        method: 'get',
+        path: '/v1/checkout_sessions',
+        tag: 'Checkout Sessions',
+        summary: 'List Checkout Sessions',
+        auth: 'service',
+        scope: 'payments:read',
+        query: exports.listCheckoutSessionsQuery,
+        response: (0, envelopes_1.listOf)(exports.checkoutSessionSchema),
+        sdk: 'checkout.sessions.list',
+        expandable: 'checkout_session',
+    }),
+    (0, route_1.defineRoute)({
+        operationId: 'retrieveCheckoutSession',
+        method: 'get',
+        path: '/v1/checkout_sessions/{id}',
+        tag: 'Checkout Sessions',
+        summary: 'Retrieve a Checkout Session',
+        auth: 'service',
+        scope: 'payments:read',
+        params: sessionId,
+        query: params_1.expandOnlyQuery,
+        response: exports.checkoutSessionSchema,
+        sdk: 'checkout.sessions.retrieve',
+        expandable: 'checkout_session',
+    }),
+    (0, route_1.defineRoute)({
+        operationId: 'updateCheckoutSession',
+        method: 'post',
+        path: '/v1/checkout_sessions/{id}',
+        tag: 'Checkout Sessions',
+        summary: 'Update a Checkout Session',
+        description: '`metadata` only, as a patch.',
+        auth: 'service',
+        scope: 'payments:write',
+        idempotent: true,
+        params: sessionId,
+        body: exports.updateCheckoutSessionParams,
+        response: exports.checkoutSessionSchema,
+        sdk: 'checkout.sessions.update',
+        expandable: 'checkout_session',
+    }),
+    (0, route_1.defineRoute)({
+        operationId: 'expireCheckoutSession',
+        method: 'post',
+        path: '/v1/checkout_sessions/{id}/expire',
+        tag: 'Checkout Sessions',
+        summary: 'Expire a Checkout Session',
+        description: 'An `open` session the payer has not confirmed; it can no longer be completed.',
+        auth: 'service',
+        scope: 'payments:write',
+        idempotent: true,
+        params: sessionId,
+        body: exports.expireCheckoutSessionParams,
+        response: exports.checkoutSessionSchema,
+        sdk: 'checkout.sessions.expire',
+        expandable: 'checkout_session',
+    }),
+    (0, route_1.defineRoute)({
+        operationId: 'listCheckoutSessionLineItems',
+        method: 'get',
+        path: '/v1/checkout_sessions/{id}/line_items',
+        tag: 'Checkout Sessions',
+        summary: "List a Checkout Session's line items",
+        description: "In their order (at most twenty); the cursor is a line's own `li_…`.",
+        auth: 'service',
+        scope: 'payments:read',
+        params: sessionId,
+        query: exports.listCheckoutSessionLineItemsQuery,
+        response: (0, envelopes_1.listOf)(shared_1.checkoutLineItemSchema),
+        sdk: 'checkout.sessions.listLineItems',
+        expandable: 'item',
+    }),
+    (0, route_1.defineRoute)({
+        operationId: 'retrieveCheckoutSessionPublic',
+        method: 'get',
+        path: '/v1/checkout_sessions/{id}/public',
+        tag: 'Checkout Sessions',
+        summary: 'Retrieve a Checkout Session as its payer',
+        description: payerAuth,
+        auth: 'public',
+        params: sessionId,
+        response: exports.checkoutSessionPublicSchema,
+    }),
+    (0, route_1.defineRoute)({
+        operationId: 'updateCheckoutSessionPublic',
+        method: 'post',
+        path: '/v1/checkout_sessions/{id}/public',
+        tag: 'Checkout Sessions',
+        summary: 'Update a Checkout Session as its payer',
+        description: `Quantities, promotion code, the payer's details. ${payerAuth}`,
+        auth: 'public',
+        params: sessionId,
+        body: exports.updateCheckoutSessionPublicParams,
+        response: exports.checkoutSessionPublicSchema,
+    }),
+    (0, route_1.defineRoute)({
+        operationId: 'confirmCheckoutSessionPublic',
+        method: 'post',
+        path: '/v1/checkout_sessions/{id}/public/confirm',
+        tag: 'Checkout Sessions',
+        summary: 'Confirm a Checkout Session as its payer',
+        description: `Locks the order and creates its payment (or setup): the answer carries \`payment_intent\` / \`setup_intent\`. Resolving is not completion — \`complete\` is only ever what the gateway says. ${payerAuth}`,
+        auth: 'public',
+        params: sessionId,
+        body: exports.confirmCheckoutSessionPublicParams,
+        response: exports.checkoutSessionPublicSchema,
+    }),
+    (0, route_1.defineRoute)({
+        operationId: 'expireCheckoutSessionTestHelper',
+        method: 'post',
+        path: '/v1/test_helpers/checkout_sessions/{id}/expire',
+        tag: 'Test helpers',
+        summary: 'Expire a test-mode Checkout Session now',
+        description: 'A session nobody confirmed expires on its own deadline; one around a payment expires with that payment, in the same transition.',
+        auth: 'service',
+        scope: 'payments:write',
+        idempotent: true,
+        testModeOnly: true,
+        params: sessionId,
+        body: exports.expireCheckoutSessionTestHelperParams,
+        response: exports.checkoutSessionSchema,
+        sdk: 'testHelpers.checkoutSessions.expire',
+    }),
+];