@reactionary/ucp 0.0.1

package/src/lib/ucp-shopping.openapi.d.ts

@@ -0,0 +1,2632 @@
+/**
+ * This file was auto-generated by openapi-typescript.
+ * Do not make direct changes to the file.
+ */
+export interface paths {
+    "/checkout-sessions": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Create Checkout
+         * @description Create a new checkout session.
+         */
+        post: operations["create_checkout"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/checkout-sessions/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description The unique identifier of the checkout session. */
+                id: components["parameters"]["checkout_session_id_path"];
+            };
+            cookie?: never;
+        };
+        /**
+         * Get Checkout
+         * @description Get the latest state of a checkout session.
+         */
+        get: operations["get_checkout"];
+        /**
+         * Update Checkout
+         * @description Update Checkout is a full replacement operation. A new Update Checkout operation is not permitted while Checkout status is `complete_in_progress`. Duplicate requests remain subject to Replay Protection. If the Business receives a new Update Checkout request in that state, it leaves the Checkout unchanged and returns the current Checkout with a recoverable error Message.
+         */
+        put: operations["update_checkout"];
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/checkout-sessions/{id}/complete": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description The unique identifier of the checkout session. */
+                id: components["parameters"]["checkout_session_id_path"];
+            };
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Complete Checkout
+         * @description Place the order
+         */
+        post: operations["complete_checkout"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/checkout-sessions/{id}/cancel": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description The unique identifier of the checkout session. */
+                id: components["parameters"]["checkout_session_id_path"];
+            };
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Cancel Checkout
+         * @description Cancel a checkout session
+         */
+        post: operations["cancel_checkout"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/carts": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Create Cart
+         * @description Create a new cart session.
+         */
+        post: operations["create_cart"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/carts/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description The unique identifier of the cart. */
+                id: components["parameters"]["cart_id_path"];
+            };
+            cookie?: never;
+        };
+        /**
+         * Get Cart
+         * @description Get the latest state of a cart session.
+         */
+        get: operations["get_cart"];
+        /**
+         * Update Cart
+         * @description Update a cart session.
+         */
+        put: operations["update_cart"];
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/carts/{id}/cancel": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description The unique identifier of the cart. */
+                id: components["parameters"]["cart_id_path"];
+            };
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Cancel Cart
+         * @description Cancel a cart session. Returns the cart state at time of cancellation.
+         */
+        post: operations["cancel_cart"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/catalog/search": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Search Catalog
+         * @description Search for products in the business's catalog.
+         */
+        post: operations["search_catalog"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/catalog/lookup": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Batch Lookup Catalog Items
+         * @description Lookup one or more products by ID with explicit market context. Supports batch lookups of multiple items in a single request.
+         */
+        post: operations["lookup_catalog"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/orders/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description The unique identifier of the order. */
+                id: components["parameters"]["order_id_path"];
+            };
+            cookie?: never;
+        };
+        /**
+         * Get Order
+         * @description Get the current state of an order. Returns the full order entity as a current-state snapshot. The business verifies the requesting platform created the checkout that produced this order.
+         */
+        get: operations["get_order"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/catalog/product": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Get Product Details
+         * @description Retrieve complete product detail by identifier. Returns a singular product with a relevant set of variants, exact pricing, and real-time availability. Supports interactive option selection via `selected` and `preferences` parameters for variant narrowing and availability signals.
+         */
+        post: operations["get_product"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+}
+export interface webhooks {
+    orderEvent: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Order Event Webhook
+         * @description Merchant sends order lifecycle events to the platform's registered webhook URL. The platform provides the webhook URL during partner onboarding.
+         */
+        post: operations["order_event_webhook"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+}
+export interface components {
+    schemas: {
+        /**
+         * Checkout
+         * @description Base checkout schema. Extensions compose onto this using allOf.
+         */
+        checkout: {
+            ucp: components["schemas"]["response_checkout_schema"];
+            /** @description Unique identifier of the checkout session. */
+            id: string;
+            /** @description List of line items being checked out. */
+            line_items: components["schemas"]["line_item"][];
+            /** @description Representation of the buyer. */
+            buyer?: components["schemas"]["buyer"];
+            context?: components["schemas"]["context"];
+            signals?: components["schemas"]["signals"];
+            attribution?: components["schemas"]["attribution"];
+            /**
+             * @description Checkout state indicating the current phase and required processing. See Checkout Status lifecycle documentation for state transition details.
+             * @enum {string}
+             */
+            status: "incomplete" | "requires_escalation" | "ready_for_complete" | "complete_in_progress" | "completed" | "canceled";
+            /** @description ISO 4217 currency code reflecting the merchant's market determination. Derived from address, context, and geo IP—buyers provide signals, merchants determine currency. */
+            currency: string;
+            /** @description Different cart totals. */
+            totals: components["schemas"]["totals"];
+            /** @description Outstanding extension-defined Actions for this checkout. */
+            actions?: components["schemas"]["actions"];
+            /** @description List of messages with error and info about the checkout session state. */
+            messages?: components["schemas"]["message"][];
+            /** @description Links to be displayed by the platform (Privacy Policy, TOS). Mandatory for legal compliance. */
+            links: components["schemas"]["link"][];
+            /** @description Policies (e.g., return/refund terms) that apply to the items in this checkout. `applies_to` targets are relative to the response root; when absent or empty, refer to the URLs in `links[]`. */
+            policies?: components["schemas"]["policy"][];
+            /**
+             * Format: date-time
+             * @description RFC 3339 expiry timestamp. Default TTL is 6 hours from creation if not sent.
+             */
+            expires_at?: string;
+            /**
+             * Format: uri
+             * @description URL for checkout handoff and session recovery. MUST be provided when status is requires_escalation. See specification for format and availability requirements.
+             */
+            continue_url?: string;
+            payment?: components["schemas"]["payment"];
+            /** @description Details about an order created for this checkout session. */
+            order?: components["schemas"]["order_confirmation"];
+        } & {
+            [key: string]: unknown;
+        };
+        checkout_response: components["schemas"]["checkout"] | components["schemas"]["error_response"];
+        /**
+         * Cart
+         * @description Shopping cart with estimated pricing before checkout. Lightweight pre-purchase exploration with no payment info or complex status states.
+         */
+        cart: {
+            ucp: components["schemas"]["response_cart_schema"];
+            /** @description Unique cart identifier. */
+            id: string;
+            /** @description Cart line items. Same structure as checkout. Full replacement on update. */
+            line_items: components["schemas"]["line_item"][];
+            /** @description Buyer signals for localization (country, region, postal_code). Merchant uses for pricing, availability, currency. Falls back to geo-IP if omitted. */
+            context?: components["schemas"]["context"];
+            signals?: components["schemas"]["signals"];
+            attribution?: components["schemas"]["attribution"];
+            /** @description Optional buyer information for personalized estimates. */
+            buyer?: components["schemas"]["buyer"];
+            /** @description ISO 4217 currency code. Determined by merchant based on context or geo-IP. */
+            currency: string;
+            /** @description Estimated cost breakdown. May be partial if shipping/tax not yet calculable. */
+            totals: components["schemas"]["totals"];
+            /** @description Outstanding extension-defined Actions for this cart. */
+            actions?: components["schemas"]["actions"];
+            /** @description Validation messages, warnings, or informational notices. */
+            messages?: components["schemas"]["message"][];
+            /** @description Optional merchant links (policies, FAQs). */
+            links?: components["schemas"]["link"][];
+            /** @description Policies (e.g., return/refund terms) that apply to the items in this cart. `applies_to` targets are relative to the response root; when absent or empty, refer to the URLs in `links[]`. */
+            policies?: components["schemas"]["policy"][];
+            /**
+             * Format: uri
+             * @description URL for cart handoff and session recovery. Enables sharing and human-in-the-loop flows.
+             */
+            continue_url?: string;
+            /**
+             * Format: date-time
+             * @description Cart expiry timestamp (RFC 3339). Optional.
+             */
+            expires_at?: string;
+            $defs: {
+                /**
+                 * Checkout with Cart
+                 * @description Checkout extended with cart capability. Adds cart_id to create_checkout for cart-to-checkout conversion.
+                 */
+                checkout: components["schemas"]["checkout"] & {
+                    /** @description Cart ID to convert to checkout. Business MUST use cart contents (line_items, context, buyer) and MUST ignore overlapping fields in checkout payload. */
+                    cart_id?: string;
+                };
+            };
+        } & {
+            [key: string]: unknown;
+        };
+        cart_response: components["schemas"]["cart"] | components["schemas"]["error_response"];
+        /**
+         * Order
+         * @description Order schema with line items, buyer-facing fulfillment expectations, and event logs.
+         */
+        order: {
+            ucp: components["schemas"]["response_order_schema"];
+            /** @description Unique order identifier. */
+            id: string;
+            /** @description Human-readable label for identifying the order. MUST only be provided by the business. */
+            label?: string;
+            /** @description Associated checkout ID for reconciliation. */
+            checkout_id: string;
+            /**
+             * Format: uri
+             * @description Permalink to access the order on merchant site.
+             */
+            permalink_url: string;
+            /** @description Line items representing what was purchased — can change post-order via edits or exchanges. */
+            line_items: components["schemas"]["order_line_item"][];
+            /** @description Fulfillment data: buyer expectations and what actually happened. */
+            fulfillment: {
+                /** @description Buyer-facing groups representing when/how items will be delivered. Can be split, merged, or adjusted post-order. */
+                expectations?: components["schemas"]["expectation"][];
+                /** @description Append-only event log of actual shipments. Each event references line items by ID. */
+                events?: components["schemas"]["fulfillment_event"][];
+            };
+            /** @description Post-order events (refunds, returns, credits, disputes, cancellations, etc.) that exist independently of fulfillment. */
+            adjustments?: components["schemas"]["adjustment"][];
+            /** @description ISO 4217 currency code. MUST match the currency from the originating checkout session. */
+            currency: string;
+            /** @description Different totals for the order. */
+            totals: components["schemas"]["totals"];
+            /** @description Snapshot of the policies that applied to the items at checkout, captured on the order as a durable record. `applies_to` targets are relative to the response root. */
+            policies?: components["schemas"]["policy"][];
+            /** @description Business outcome messages (errors, warnings, informational). Present when the business needs to communicate status or issues to the platform. */
+            messages?: components["schemas"]["message"][];
+            /** @description Snapshot of the attribution associated with the originating checkout. Read-only on the order. */
+            attribution?: components["schemas"]["attribution"];
+            $defs: {
+                /**
+                 * Platform Order Schema
+                 * @description Platform's order capability configuration.
+                 */
+                platform_schema: {
+                    /**
+                     * Format: uri
+                     * @description URL where merchant sends order lifecycle events (webhooks).
+                     */
+                    webhook_url: string;
+                };
+            };
+        };
+        order_response: components["schemas"]["order"] | components["schemas"]["error_response"];
+        /**
+         * Payment
+         * @description Payment configuration containing handlers.
+         */
+        payment: {
+            /** @description The payment instruments available for this payment. Each instrument is associated with a specific handler via the handler_id field. Handlers can extend the base payment_instrument schema to add handler-specific fields. */
+            instruments?: components["schemas"]["selected_payment_instrument"][];
+        };
+        /**
+         * UCP Metadata
+         * @description Protocol metadata for discovery profiles and responses. Uses slim schema pattern with context-specific required fields.
+         */
+        ucp: {
+            $defs: {
+                /** @description Version identifier in YYYY-MM-DD format. */
+                version: string;
+                /** @description Version range requirement with minimum and optional maximum. */
+                version_constraint: {
+                    /** @description Minimum required version (inclusive). */
+                    min: components["schemas"]["version"];
+                    /** @description Maximum compatible version (inclusive). When absent, no upper bound. */
+                    max?: components["schemas"]["version"];
+                } & {
+                    [key: string]: unknown;
+                };
+                /** @description Version requirements for extension schemas. Declares minimum (and optionally maximum) protocol and capability versions needed for correct operation. */
+                requires: {
+                    /** @description Required range for the selected `ucp.version`. */
+                    protocol?: components["schemas"]["version_constraint"];
+                    /** @description Required capability versions, keyed by capability name. Keys must be a subset of the extension's $defs keys. */
+                    capabilities?: {
+                        [key: string]: components["schemas"]["version_constraint"];
+                    };
+                } & {
+                    [key: string]: unknown;
+                };
+                /** @description Preferred key order for map-valued fields in the scope annotated by the containing `ucp` member. Each property names a target map, and its array lists target keys in preferred order. Lists may be partial and are not allowlists. */
+                map_order: {
+                    [key: string]: string[];
+                };
+                /** @description Members defined inside the reserved `ucp` protocol object. The object is open for forward compatibility: consumers MUST ignore unrecognized members. Only UCP core defines members, and every defined member MUST be safe to ignore. */
+                members: {
+                    map_order?: components["schemas"]["map_order"];
+                    request_constraints?: components["schemas"]["request_constraints"];
+                } & {
+                    [key: string]: unknown;
+                };
+                /** @description Shared foundation for all UCP entities. */
+                entity: {
+                    /** @description Entity version in YYYY-MM-DD format. */
+                    version: components["schemas"]["version"];
+                    /**
+                     * Format: uri
+                     * @description URL to human-readable specification document.
+                     */
+                    spec?: string;
+                    /**
+                     * Format: uri
+                     * @description URL to JSON Schema defining this entity's structure and payloads.
+                     */
+                    schema?: string;
+                    /** @description Unique identifier for this entity instance. Used to disambiguate when multiple instances exist. */
+                    id?: string;
+                    /** @description Entity-specific configuration. Structure defined by each entity's schema. */
+                    config?: {
+                        [key: string]: unknown;
+                    };
+                };
+                /** @description Base UCP metadata with shared properties for all schema types. */
+                base: {
+                    version: components["schemas"]["version"];
+                    /** @description Preferred key-traversal order for sibling registry fields inside the root `ucp` envelope (`services`, `capabilities`, and `payment_handlers`). */
+                    map_order?: components["schemas"]["map_order"];
+                    /**
+                     * @description Application-level status of the UCP operation.
+                     * @default success
+                     * @enum {string}
+                     */
+                    status: "success" | "error";
+                    /** @description Service registry keyed by reverse-domain name. */
+                    services?: {
+                        [key: string]: components["schemas"]["base"][];
+                    };
+                    /** @description Capability registry keyed by reverse-domain name. */
+                    capabilities?: {
+                        [key: string]: components["schemas"]["$defs-base"][];
+                    };
+                    /** @description Payment handler registry keyed by reverse-domain name. */
+                    payment_handlers?: {
+                        [key: string]: components["schemas"]["payment_handler_$defs-base"][];
+                    };
+                };
+                /** @description UCP metadata with status 'success'. Use for response branches that carry the expected payload. */
+                success: components["schemas"]["ucp_$defs-base"] & {
+                    /** @constant */
+                    status: "success";
+                };
+                /** @description UCP metadata with status 'error'. Use for response branches that carry error information. */
+                error: components["schemas"]["ucp_$defs-base"] & {
+                    /** @constant */
+                    status: "error";
+                };
+                /**
+                 * UCP Platform Schema
+                 * @description Full UCP metadata for platform-level configuration. Hosted at a URI advertised by the platform in request headers.
+                 */
+                platform_schema: components["schemas"]["ucp_$defs-base"] & {
+                    services: {
+                        [key: string]: unknown;
+                    };
+                    capabilities?: {
+                        [key: string]: unknown;
+                    };
+                    payment_handlers: {
+                        [key: string]: unknown;
+                    };
+                };
+                /**
+                 * UCP Business Schema
+                 * @description UCP metadata for business/merchant-level configuration. Subset of platform schema with business-specific settings.
+                 */
+                business_schema: components["schemas"]["ucp_$defs-base"] & {
+                    /** @description Previous protocol versions this business supports, mapped to profile URIs. Businesses that support older protocol versions SHOULD advertise each version and link to its profile. Each URI points to a complete, self-contained profile for that version. When omitted, only `version` is supported. */
+                    supported_versions?: {
+                        [key: string]: string;
+                    };
+                    services: {
+                        [key: string]: unknown;
+                    };
+                    capabilities?: {
+                        [key: string]: unknown;
+                    };
+                    payment_handlers: {
+                        [key: string]: unknown;
+                    };
+                };
+                /**
+                 * UCP Checkout Response Schema
+                 * @description UCP metadata for checkout responses.
+                 */
+                response_checkout_schema: components["schemas"]["ucp_$defs-base"] & {
+                    services?: {
+                        [key: string]: unknown;
+                    };
+                    capabilities?: {
+                        [key: string]: unknown;
+                    };
+                    payment_handlers: {
+                        [key: string]: unknown;
+                    };
+                };
+                /**
+                 * UCP Order Response Schema
+                 * @description UCP metadata for order responses. No payment handlers needed post-purchase.
+                 */
+                response_order_schema: components["schemas"]["ucp_$defs-base"] & {
+                    capabilities?: {
+                        [key: string]: unknown;
+                    };
+                };
+                /**
+                 * UCP Cart Response Schema
+                 * @description UCP metadata for cart responses. No payment handlers needed pre-checkout.
+                 */
+                response_cart_schema: components["schemas"]["ucp_$defs-base"] & {
+                    capabilities?: {
+                        [key: string]: unknown;
+                    };
+                };
+                /**
+                 * UCP Catalog Response Schema
+                 * @description UCP metadata for catalog responses.
+                 */
+                response_catalog_schema: components["schemas"]["ucp_$defs-base"] & {
+                    capabilities?: {
+                        [key: string]: unknown;
+                    };
+                };
+                /**
+                 * UCP Location Response Schema
+                 * @description UCP metadata for location responses.
+                 */
+                response_location_schema: components["schemas"]["ucp_$defs-base"] & {
+                    capabilities?: {
+                        [key: string]: unknown;
+                    };
+                };
+            };
+        };
+        catalog_search_request: components["schemas"]["search_request"];
+        catalog_search_response: components["schemas"]["search_response"];
+        catalog_lookup_request: components["schemas"]["lookup_request"];
+        catalog_lookup_response: components["schemas"]["lookup_response"];
+        catalog_get_product_request: components["schemas"]["get_product_request"];
+        catalog_get_product_response: components["schemas"]["get_product_response"] | components["schemas"]["error_response"];
+        /** @description Version identifier in YYYY-MM-DD format. */
+        version: string;
+        /** @description Preferred key order for map-valued fields in the scope annotated by the containing `ucp` member. Each property names a target map, and its array lists target keys in preferred order. Lists may be partial and are not allowlists. */
+        map_order: {
+            [key: string]: string[];
+        };
+        /**
+         * Reverse Domain Name
+         * @description Reverse-domain identifier used for collision-safe namespacing of capabilities, services, handlers, eligibility claims, and extension-contributed keys. Must contain at least two dot-separated segments (e.g., 'dev.ucp.shopping.checkout', 'com.example.loyalty_gold'). Segments after the first are domain- or identifier-derived: they may contain interior hyphens, may start with a digit, and may contain underscores (e.g., 'com.example-shop.checkout', 'com.2example.cart', 'dev.ucp.common.identity_linking'), but must not start or end with a hyphen. The first segment (the reversed top-level domain) is letters and digits, and may contain interior hyphens to support internationalized (punycode) top-level domains such as 'xn--p1ai'.
+         * @example dev.ucp.shopping.checkout
+         * @example dev.ucp.common.identity_linking
+         * @example com.example.loyalty_gold
+         * @example com.example-shop.checkout
+         * @example com.2example.cart
+         * @example uk.co.example-shop.checkout
+         * @example xn--p1ai.example.checkout
+         */
+        reverse_domain_name: string;
+        /** @description Shared foundation for all UCP entities. */
+        entity: {
+            /** @description Entity version in YYYY-MM-DD format. */
+            version: components["schemas"]["version"];
+            /**
+             * Format: uri
+             * @description URL to human-readable specification document.
+             */
+            spec?: string;
+            /**
+             * Format: uri
+             * @description URL to JSON Schema defining this entity's structure and payloads.
+             */
+            schema?: string;
+            /** @description Unique identifier for this entity instance. Used to disambiguate when multiple instances exist. */
+            id?: string;
+            /** @description Entity-specific configuration. Structure defined by each entity's schema. */
+            config?: {
+                [key: string]: unknown;
+            };
+        };
+        base: components["schemas"]["entity"] & {
+            /**
+             * @description Transport protocol for this service binding.
+             * @enum {string}
+             */
+            transport: "rest" | "mcp" | "a2a" | "embedded";
+            /**
+             * Format: uri
+             * @description Endpoint URL for this transport binding.
+             */
+            endpoint?: string;
+        };
+        "$defs-base": components["schemas"]["entity"] & {
+            /** @description Parent capability(s) this extends. Present for extensions, absent for root capabilities. Use array for multi-parent extensions. */
+            extends?: components["schemas"]["reverse_domain_name"] | components["schemas"]["reverse_domain_name"][];
+        };
+        /**
+         * Constraint Expression
+         * @description A closed JSON Schema Draft 2020-12 constraint expression with Object and Value Constraint positions.
+         */
+        constraint_expression: {
+            /** @description Property names required by the constrained object. Must be non-empty: an empty array applies no constraint. */
+            required?: string[];
+            /** @description Constraints keyed by property name. Must be non-empty: an empty object applies no constraint. */
+            properties?: {
+                [key: string]: components["schemas"]["constraint_expression"] | components["schemas"]["value_constraint"];
+            };
+            /** @description Alternative Object Constraints. The constrained object must satisfy at least one. A branch must be non-empty: an empty branch is satisfied by every object and neutralizes the alternation. */
+            anyOf?: components["schemas"]["constraint_expression"][];
+            $defs: {
+                /** @description A Value Constraint containing `enum`, `const`, or both. */
+                value_constraint: {
+                    /** @description A non-empty array of unique JSON values. */
+                    enum?: unknown[];
+                    const?: unknown;
+                } | unknown | unknown;
+            };
+        };
+        /** @description A Value Constraint containing `enum`, `const`, or both. */
+        value_constraint: {
+            /** @description A non-empty array of unique JSON values. */
+            enum?: unknown[];
+            const?: unknown;
+        } | unknown | unknown;
+        /**
+         * Available Payment Instrument
+         * @description An instrument type available from a payment handler with optional constraints.
+         */
+        available_payment_instrument: {
+            /** @description The instrument type identifier (e.g., 'card', 'gift_card'). References an instrument schema's type constant. */
+            type: string;
+            /** @description A Constraint Expression describing the instrument this entry makes available. Keys in `properties` name members of the `constraint_target` declared by the instrument schema for this `type`. Requirements on submitted request data belong in `ucp.request_constraints` instead. */
+            constraints?: components["schemas"]["constraint_expression"];
+        };
+        "payment_handler_$defs-base": components["schemas"]["entity"] & Record<string, never> & {
+            /** @description Instrument types this handler supports, with optional constraints. When absent, every instrument should be considered available. */
+            available_instruments?: components["schemas"]["available_payment_instrument"][];
+        };
+        /** @description Base UCP metadata with shared properties for all schema types. */
+        "ucp_$defs-base": {
+            version: components["schemas"]["version"];
+            /** @description Preferred key-traversal order for sibling registry fields inside the root `ucp` envelope (`services`, `capabilities`, and `payment_handlers`). */
+            map_order?: components["schemas"]["map_order"];
+            /**
+             * @description Application-level status of the UCP operation.
+             * @default success
+             * @enum {string}
+             */
+            status: "success" | "error";
+            /** @description Service registry keyed by reverse-domain name. */
+            services?: {
+                [key: string]: components["schemas"]["base"][];
+            };
+            /** @description Capability registry keyed by reverse-domain name. */
+            capabilities?: {
+                [key: string]: components["schemas"]["$defs-base"][];
+            };
+            /** @description Payment handler registry keyed by reverse-domain name. */
+            payment_handlers?: {
+                [key: string]: components["schemas"]["payment_handler_$defs-base"][];
+            };
+        };
+        /**
+         * Embedded Transport Config
+         * @description Per-session configuration for embedded transport binding. Allows businesses to vary EP availability and delegations based on cart contents, agent authorization, or policy.
+         */
+        embedded_config: {
+            /** @description Delegations the business allows. At service-level, declares available delegations. In UCP responses, confirms accepted delegations for this session. */
+            delegate?: string[];
+            /** @description Color schemes the business supports. Hosts use ec_color_scheme query parameter to request a scheme from this list. */
+            color_scheme?: ("light" | "dark")[];
+        };
+        /**
+         * Service (Response Schema)
+         * @description Service binding in API responses. Includes per-resource transport configuration via typed config.
+         */
+        response_schema: components["schemas"]["base"] & ({
+            /** @constant */
+            transport?: "rest";
+        } | {
+            /** @constant */
+            transport?: "mcp";
+        } | {
+            /** @constant */
+            transport?: "a2a";
+        } | {
+            /** @constant */
+            transport?: "embedded";
+            config?: components["schemas"]["embedded_config"];
+        });
+        /**
+         * Capability (Response Schema)
+         * @description Capability reference in responses. Only name/version required to confirm active capabilities.
+         */
+        "$defs-response_schema": components["schemas"]["$defs-base"];
+        /**
+         * Payment Handler (Response Schema)
+         * @description Handler reference in responses. May include full config state for runtime usage of the handler.
+         */
+        "payment_handler_$defs-response_schema": components["schemas"]["payment_handler_$defs-base"];
+        /**
+         * UCP Checkout Response Schema
+         * @description UCP metadata for checkout responses.
+         */
+        response_checkout_schema: components["schemas"]["ucp_$defs-base"] & {
+            services?: {
+                [key: string]: unknown;
+            };
+            capabilities?: {
+                [key: string]: unknown;
+            };
+            payment_handlers: {
+                [key: string]: unknown;
+            };
+        };
+        /**
+         * Amount
+         * @description Monetary amount in the currency's minor unit as defined by ISO 4217. Refer to the currency's exponent to determine minor-to-major ratio (e.g., 2 for USD, 0 for JPY, 3 for KWD).
+         */
+        amount: number;
+        /**
+         * Unit
+         * @description A reusable unit descriptor for quantities and measures. Its unit-descriptor machine identity is (`unit`, effective `scale`), where effective `scale` is the provided `scale` or 0; `display_text` is excluded.
+         */
+        unit: {
+            /** @description Stable machine identifier. The Business SHOULD use the exact UN/CEFACT Rec20 Common Code when one accurately identifies the unit. Otherwise, the Business MAY use a custom unit identifier and MUST use it consistently for the same unit. The Platform MUST treat an unrecognized identifier as opaque. */
+            unit: string;
+            /**
+             * @description One step equals `10^-scale` of `unit`. When `unit` is `C62`, `scale`, if present, MUST be 0. The maximum of 15 is derived from the interoperable integer range: at scale 16 a single whole unit (10^16 steps) is no longer representable, so larger scales cannot denominate one unit of their own basis. Businesses needing finer granularity use a smaller unit.
+             * @default 0
+             */
+            scale: number;
+            /** @description Required printable unit label provided by the Business. The Platform MUST use it when it does not recognize `unit`; for a recognized UN/CEFACT Rec 20 Common Code, the Platform MAY substitute its own localized label. It does not participate in unit identity or mismatch comparison. */
+            display_text: string;
+        } & unknown;
+        /**
+         * Quantity Unit
+         * @description Sale-basis descriptor for quantities: the shared unit descriptor plus the Business's ordering policy. Its unit-descriptor machine identity remains (`unit`, effective `scale`); `display_text` and `increment` are excluded from identity and mismatch comparison.
+         */
+        quantity_unit: components["schemas"]["unit"] & {
+            /**
+             * @description Ordering granularity, denominated in steps: the Business sells this item in integer multiples of `increment` steps. Its effective value is the provided value or 1. Advisory merchandising policy, not a representational bound: Platform-authored quantities SHOULD be integer multiples of the effective increment; the Business MAY accept, revise, or reject an off-increment request with a recoverable business outcome and MUST NOT silently reinterpret it. Business-authored quantities (checkout revisions, fulfillment events, adjustments) are bounded only by `scale`.
+             * @default 1
+             */
+            increment: number;
+        };
+        /**
+         * Measure
+         * @description A measure composed of an integer value and a unit descriptor. Its value is the integer count of `10^-scale` units of `unit`.
+         */
+        measure: components["schemas"]["unit"] & {
+            /** @description Integer count of `10^-scale` units of `unit`. */
+            value: number;
+        };
+        /**
+         * Unit Price
+         * @description Price per standard unit of measurement. MAY be omitted when unit pricing does not apply. `unit_price.currency` MUST equal `price.currency`; the comparator MUST NOT perform currency conversion. `measure.unit` and `reference.unit` MUST be identical; cross-unit conversion is not permitted. Their scales MAY differ; each value represents `value × 10^-scale`.
+         */
+        unit_price: {
+            /** @description Unit price in ISO 4217 minor units. After satisfying the same-unit invariant, the Business MUST compute the comparator as `(price.amount / (measure.value × 10^-measure.scale)) × (reference.value × 10^-reference.scale)` and round it once to ISO 4217 minor units according to its pricing rules. The returned `unit_price.amount` is authoritative; the Platform MUST NOT recompute or substitute its own result. */
+            amount: components["schemas"]["amount"];
+            /** @description ISO 4217 currency code. */
+            currency: string;
+            /** @description Product quantity in packaging/content (for example, a 750 mL bottle), distinct from `quantity_unit`, which defines the sale basis. Its integer `value` MUST be at least 1. */
+            measure: components["schemas"]["measure"] & {
+                value?: unknown;
+            };
+            /** @description Denominator for unit price display (for example, per 100 mL or per 1 kg). Its integer `value` MUST be at least 1. */
+            reference: components["schemas"]["measure"] & {
+                value?: unknown;
+            };
+        };
+        /** Item */
+        item: {
+            /** @description The product identifier, often the SKU, required to resolve the product details associated with this line item. Should be recognized by both the Platform, and the Business. */
+            id: string;
+            /** @description Product title. */
+            title: string;
+            /** @description Unit price in ISO 4217 minor units. Price is the amount per one whole `quantity_unit.unit` (for example, per lb or per hour); when `quantity_unit` is absent, it is per `each`. */
+            price: components["schemas"]["amount"];
+            /** @description Sale basis this item's `quantity` is denominated in. On an authoritative Business response, absence encodes the default `each` machine identity (`C62`, 0); the Business MUST include this descriptor for every non-`each` response. On Platform requests, omission makes no assertion: the Business interprets `quantity` using the item's authoritative sale basis. If the Platform includes this descriptor, it asserts the unit-descriptor machine identity. The Business MUST compare that machine identity (`unit`, effective `scale`), ignore `display_text` and `increment`, and resolve a mismatch by conversion surfaced as a visible line revision with a warning, or by rejection with a recoverable business outcome; silent reinterpretation is forbidden. An explicit `C62` descriptor at effective scale 0 matches an authoritative basis represented by an absent descriptor. */
+            quantity_unit?: components["schemas"]["quantity_unit"];
+            /** @description Pricing basis for this item. On an authoritative Business response, the Business MUST include `unit_price` on every line whose pricing basis differs from its sale basis (for example, priced per pound but sold per `each`); presence on a line marks the rate as transactional rather than display-only. When the pricing basis is the sale basis, `item.price` fully denominates the charge and this field MAY be omitted. */
+            unit_price?: components["schemas"]["unit_price"];
+            /**
+             * Format: uri
+             * @description Product image URI.
+             */
+            image_url?: string;
+        };
+        /**
+         * Signed Amount
+         * @description Monetary amount in the currency's minor unit as defined by ISO 4217. Refer to the currency's exponent to determine minor-to-major ratio (e.g., 2 for USD, 0 for JPY, 3 for KWD). May be negative — the sign is intrinsic to the value (e.g., discounts are negative, charges are positive).
+         */
+        signed_amount: number;
+        /**
+         * Total
+         * @description A cost breakdown entry with a category, amount, and optional display text.
+         */
+        total: {
+            /** @description Cost category. Well-known values: subtotal, items_discount, discount, fulfillment, tax, fee, total. Businesses MAY use additional values. */
+            type: string;
+            /** @description Text to display against the amount. Should reflect appropriate method (e.g., 'Shipping', 'Delivery'). */
+            display_text?: string;
+            amount: components["schemas"]["signed_amount"];
+        } & (unknown & unknown);
+        /**
+         * Line Item
+         * @description Line item object. Expected to use the currency of the parent object.
+         */
+        line_item: {
+            id: string;
+            item: components["schemas"]["item"];
+            /** @description Always an integer step count. On Platform requests, steps use the item's Business-authoritative sale basis; omitting `item.quantity_unit` makes no assertion and does not imply `each`. On Business responses, `item.quantity_unit` describes the basis; if absent, it encodes the `each` machine identity (`C62`, 0) and `quantity` counts whole items. */
+            quantity: number;
+            /** @description Line item totals breakdown. */
+            totals: components["schemas"]["total"][];
+            /** @description Parent line item identifier for any nested structures. */
+            parent_id?: string;
+        };
+        /** Buyer */
+        buyer: {
+            /** @description First name of the buyer. */
+            first_name?: string;
+            /** @description Last name of the buyer. */
+            last_name?: string;
+            /** @description Email of the buyer. */
+            email?: string;
+            /** @description E.164 standard. */
+            phone_number?: string;
+        } & {
+            [key: string]: unknown;
+        };
+        /**
+         * Locality
+         * @description A coarse geographic location — country, region, and postal code. A lightweight alternative to a full postal address.
+         */
+        locality: {
+            /** @description The country, as a 2-letter ISO 3166-1 alpha-2 code (e.g. "US"). A 3-letter alpha-3 code or full country name MAY also be used. */
+            address_country?: string;
+            /** @description The first-level administrative region within the country (e.g. a state or province such as California). */
+            address_region?: string;
+            /** @description The postal code (e.g. "94043"). */
+            postal_code?: string;
+        } & {
+            [key: string]: unknown;
+        };
+        /**
+         * Context
+         * @description Provisional buyer signals for relevance and localization—not authoritative data. Businesses SHOULD use these values when verified inputs (e.g., shipping address) are absent, and MAY ignore or down-rank them if inconsistent with higher-confidence signals (authenticated account, risk detection) or regulatory constraints (export controls). Eligibility and policy enforcement MUST occur at checkout time using binding transaction data. Context SHOULD be non-identifying and can be disclosed progressively—coarse signals early, finer resolution as the session progresses. Higher-resolution data (shipping address, billing address) supersedes context.
+         */
+        context: {
+            [key: string]: unknown;
+        } & (components["schemas"]["locality"] & ({
+            /** @description Stable, opaque identifier for a Location in the Business's namespace. This provisional, non-binding hint is distinct from the Buyer's locality. The operation specification or an active capability/extension defines its effects. A common example in retail shopping is the default home store ID selected and saved by the user when purchasing groceries. */
+            location?: string;
+            /** @description Background context describing buyer's intent (e.g., 'looking for a gift under $50', 'need something durable for outdoor use'). Informs relevance, recommendations, and personalization. */
+            intent?: string;
+            /** @description Preferred language for content. Use IETF BCP 47 language tags (e.g., 'en', 'fr-CA', 'zh-Hans'). For REST, equivalent to Accept-Language header—platforms SHOULD fall back to Accept-Language when this field is absent; when provided, overrides Accept-Language. Businesses MAY return content in a different language if unavailable. */
+            language?: string;
+            /** @description Preferred currency (ISO 4217, e.g., 'EUR', 'USD'). Businesses determine presentment currency from context and authoritative signals; this hint MAY inform selection in multi-currency markets. Also serves as the denomination for price filter values — platforms SHOULD include this field when sending price filters. Response prices include explicit currency confirming the resolution. */
+            currency?: string;
+            /** @description Buyer claims about eligible benefits such as loyalty membership, payment instrument perks, and similar. Recognized claims MAY inform the Business response (e.g., member-only product availability, adjusted pricing in catalog, provisional discounts at cart or checkout). Businesses MUST ignore unrecognized values without error. Values MUST use reverse-domain naming (e.g., 'com.example.loyalty_gold', 'org.school.student') and MUST be non-identifying. */
+            eligibility?: components["schemas"]["reverse_domain_name"][];
+            /** @description Buyer-preferred payment handlers in priority order (most preferred first). Each entry names a handler advertised in the Business profile's `ucp.payment_handlers`, optionally narrowed to preferred instrument types. The Business SHOULD use it to preselect or prioritize the handler (and type, when given) and MAY ignore unavailable or ineligible entries; unrecognized values MUST be ignored without error. */
+            payment?: {
+                /** @description Handler registry key advertised in the Business profile's `ucp.payment_handlers`. */
+                handler: components["schemas"]["reverse_domain_name"];
+                /** @description Optional preferred instrument types for this handler, in priority order, aligned with the handler's advertised `payment_instrument.type` values (for example `card` or `bank`). Unrecognized values MUST be ignored. */
+                types?: string[];
+            }[];
+        } & {
+            [key: string]: unknown;
+        }));
+        /**
+         * Signals
+         * @description Environment data provided by the platform to support authorization and abuse prevention. Values MUST NOT be buyer-asserted claims — platforms provide signals based on direct observation or independently verifiable third-party attestations. All signal keys MUST use reverse-domain naming to ensure provenance and prevent collisions when multiple extensions contribute to the shared namespace.
+         */
+        signals: {
+            /** @description Client's IP address (IPv4 or IPv6). */
+            "dev.ucp.buyer_ip"?: string;
+            /** @description Client's HTTP User-Agent header or equivalent. */
+            "dev.ucp.user_agent"?: string;
+        } & {
+            [key: string]: unknown;
+        };
+        /**
+         * Attribution
+         * @description Platform-emitted referral and conversion-event context — campaign identifiers, click IDs, source/medium markers, etc. The same parameters platforms communicate via URL query parameters in browser-based flows.
+         */
+        attribution: {
+            [key: string]: string;
+        };
+        /**
+         * Totals
+         * @description Pricing breakdown provided by the business. MUST contain exactly one subtotal and one total entry. Detail types (tax, fee, discount, fulfillment) may appear multiple times for itemization. Platforms MUST render all entries in order using display_text and amount.
+         */
+        totals: (components["schemas"]["total"] & {
+            /** @description Optional itemized breakdown. The parent entry is always rendered; lines are supplementary. Sum of line amounts MUST equal the parent entry amount. */
+            lines?: {
+                /** @description Human-readable label for this sub-line. */
+                display_text: string;
+                amount: components["schemas"]["signed_amount"];
+            }[];
+        } & unknown)[] & (unknown & unknown);
+        /** @description Common fields for one outstanding Action instance are id and optional config. The extension declaring the Action type defines type-specific processing data under config. Additional properties are permitted for forward compatibility. */
+        instance: {
+            /** @description Identifier for this Action instance. */
+            id: string;
+            /** @description Configuration defined by the extension that declares this Action type. */
+            config?: {
+                [key: string]: unknown;
+            };
+        } & {
+            [key: string]: unknown;
+        };
+        /**
+         * Actions
+         * @description Outstanding extension-defined Action instances, keyed by reverse-domain Action type, not extension name.
+         */
+        actions: {
+            $defs: {
+                /** @description Common fields for one outstanding Action instance are id and optional config. The extension declaring the Action type defines type-specific processing data under config. Additional properties are permitted for forward compatibility. */
+                instance: {
+                    /** @description Identifier for this Action instance. */
+                    id: string;
+                    /** @description Configuration defined by the extension that declares this Action type. */
+                    config?: {
+                        [key: string]: unknown;
+                    };
+                } & {
+                    [key: string]: unknown;
+                };
+            };
+        } & {
+            [key: string]: components["schemas"]["instance"][];
+        };
+        /**
+         * Error Code
+         * @description Error code identifying the type of error. Standard errors are defined in capability specifications (see examples) and have standardized semantics; freeform codes are permitted.
+         * @example not_found
+         * @example out_of_stock
+         * @example item_unavailable
+         * @example address_undeliverable
+         * @example payment_failed
+         * @example eligibility_invalid
+         * @example identity_required
+         * @example insufficient_scope
+         */
+        error_code: string;
+        /** Message Error */
+        message_error: {
+            /**
+             * @description Message type discriminator.
+             * @constant
+             */
+            type: "error";
+            code: components["schemas"]["error_code"];
+            /** @description RFC 9535 JSONPath to the component the message refers to (e.g., $.line_items[0]). */
+            path?: string;
+            /**
+             * @description Content format, default = plain.
+             * @default plain
+             * @enum {string}
+             */
+            content_type: "plain" | "markdown";
+            /** @description Human-readable message. */
+            content: string;
+            /**
+             * @description Reflects the resource state and recommended action. 'recoverable': platform can resolve the condition in band, for example by modifying inputs or processing a related Action, and submit a new operation when needed. 'requires_buyer_input': merchant requires information their API doesn't support collecting programmatically (checkout incomplete). 'requires_buyer_review': buyer must authorize before order placement due to policy, regulatory, or entitlement rules. 'unrecoverable': no valid resource exists to act on, retry with new resource or inputs. Errors with 'requires_*' severity contribute to 'status: requires_escalation'.
+             * @enum {string}
+             */
+            severity: "recoverable" | "requires_buyer_input" | "requires_buyer_review" | "unrecoverable";
+        };
+        /**
+         * Warning Code
+         * @description Warning code identifying the type of warning. Standard codes are defined in capability specifications (see examples) and have standardized semantics; freeform codes are permitted.
+         * @example final_sale
+         * @example prop65
+         * @example fulfillment_changed
+         * @example payment_term_changed
+         * @example age_restricted
+         */
+        warning_code: string;
+        /** Message Warning */
+        message_warning: {
+            /**
+             * @description Message type discriminator.
+             * @constant
+             */
+            type: "warning";
+            /** @description RFC 9535 JSONPath to the component the message refers to (e.g., $.line_items[0]). */
+            path?: string;
+            code: components["schemas"]["warning_code"];
+            /** @description Human-readable warning message that MUST be displayed. */
+            content: string;
+            /**
+             * @description Content format, default = plain.
+             * @default plain
+             * @enum {string}
+             */
+            content_type: "plain" | "markdown";
+            /**
+             * @description Rendering contract for this warning. 'notice' (default): platform MUST display, MAY dismiss. 'disclosure': platform MUST display in proximity to the path-referenced component, MUST NOT hide or auto-dismiss. See specification for full contract.
+             * @default notice
+             */
+            presentation: string;
+            /**
+             * Format: uri
+             * @description URL to a required visual element (e.g., warning symbol, energy class label).
+             */
+            image_url?: string;
+            /**
+             * Format: uri
+             * @description Reference URL for more information (e.g., regulatory site, registry entry, policy page).
+             */
+            url?: string;
+        };
+        /**
+         * Info Code
+         * @description Info code identifying the type of informational message. Standard codes are defined in capability specifications (see examples) and have standardized semantics; freeform codes are permitted.
+         * @example identity_optional
+         * @example signal
+         * @example free_shipping
+         * @example not_found
+         */
+        info_code: string;
+        /** Message Info */
+        message_info: {
+            /**
+             * @description Message type discriminator.
+             * @constant
+             */
+            type: "info";
+            /** @description RFC 9535 JSONPath to the component the message refers to (e.g., $.line_items[0]). */
+            path?: string;
+            code?: components["schemas"]["info_code"];
+            /**
+             * @description Content format, default = plain.
+             * @default plain
+             * @enum {string}
+             */
+            content_type: "plain" | "markdown";
+            /** @description Human-readable message. */
+            content: string;
+        };
+        /**
+         * Message
+         * @description Container for error, warning, or info messages.
+         */
+        message: components["schemas"]["message_error"] | components["schemas"]["message_warning"] | components["schemas"]["message_info"];
+        /** Link */
+        link: {
+            /** @description Type of link. Well-known values: `privacy_policy`, `terms_of_service`, `refund_policy`, `shipping_policy`, `faq`. Consumers SHOULD handle unknown values gracefully by displaying them using the `title` field or omitting the link. */
+            type: string;
+            /**
+             * Format: uri
+             * @description The actual URL pointing to the content to be displayed.
+             */
+            url: string;
+            /** @description Optional display text for the link. When provided, use this instead of generating from type. */
+            title?: string;
+        };
+        /**
+         * Description
+         * @description Description content in one or more formats. At least one format must be provided.
+         */
+        description: {
+            /** @description Plain text content. */
+            plain?: string;
+            /** @description HTML-formatted content. Security: Platforms MUST sanitize before rendering—strip scripts, event handlers, and untrusted elements. Treat all rich text as untrusted input. */
+            html?: string;
+            /** @description Markdown-formatted content. */
+            markdown?: string;
+        };
+        /**
+         * Policy
+         * @description A durable business rule about the items in a response — return/refund terms, warranty, and the like — at the time of purchase. Every policy carries a `type` (an open reverse-DNS vocabulary) and a `description` so a platform can present it without understanding its type-specific fields; type-specific fields (gated by `type`) add structured context for platforms that model that type. Policies are reference data; the obligation to display a term to the buyer is carried by a `messages[]` warning whose `code` equals the policy `type` — see the Policies section of the specification.
+         */
+        policy: {
+            /** @description Policy type discriminator. Open reverse-DNS vocabulary. Well-known values: `dev.ucp.shopping.policy.return` (return terms), `dev.ucp.shopping.policy.warranty` (warranty terms). Businesses MAY define custom types in their own domain (e.g., `com.example.policy.price_match`). Platforms MUST tolerate unknown values. */
+            type: components["schemas"]["reverse_domain_name"];
+            /** @description Human-readable policy summary in one or more formats (plain, markdown, html). Required on every policy so a platform can present it without understanding any type-specific fields. This is not the buyer-facing disclosure — display is compelled by a `messages[]` warning (see the Policies section). */
+            description: components["schemas"]["description"];
+            /** @description RFC 9535 JSONPath expressions identifying the nodes this policy applies to, relative to the embedding response root (e.g., `$.line_items[0]` in cart/checkout, `$.products[2]` in catalog). Each target covers the node it names and everything nested under it, so a target on a product also covers its variants. A singular query (RFC 9535 Section 2.3.5.1; name and index selectors only) names a single node; filters, wildcards, and slices match a set. When omitted, the policy applies to the entire response. When policies of the same `type` contest a node, the narrowest target wins and overrides the rest. See the Policies section for how specificity resolves. */
+            applies_to?: string[];
+            /**
+             * Format: uri
+             * @description Optional link to the full policy document.
+             */
+            url?: string;
+        } & {
+            [key: string]: unknown;
+        };
+        /** Postal Address */
+        postal_address: {
+            /** @description An address extension such as an apartment number, C/O or alternative name. */
+            extended_address?: string;
+            /** @description The street address. */
+            street_address?: string;
+            /** @description The locality in which the street address is, and which is in the region. For example, Mountain View. */
+            address_locality?: string;
+            /** @description The region in which the locality is, and which is in the country. Required for applicable countries (i.e. state in US, province in CA). For example, California or another appropriate first-level Administrative division. */
+            address_region?: string;
+            /** @description The country. Recommended to be in 2-letter ISO 3166-1 alpha-2 format, for example "US". For backward compatibility, a 3-letter ISO 3166-1 alpha-3 country code such as "SGP" or a full country name such as "Singapore" can also be used. */
+            address_country?: string;
+            /** @description The postal code. For example, 94043. */
+            postal_code?: string;
+            /** @description Optional. First name of the contact associated with the address. */
+            first_name?: string;
+            /** @description Optional. Last name of the contact associated with the address. */
+            last_name?: string;
+            /** @description Optional. Phone number of the contact associated with the address. */
+            phone_number?: string;
+        };
+        /**
+         * Payment Credential
+         * @description The base definition for any payment credential. Handlers define specific credential types.
+         */
+        payment_credential: {
+            /** @description The credential type discriminator. Specific schemas will constrain this to a constant value. */
+            type: string;
+        } & {
+            [key: string]: unknown;
+        };
+        /**
+         * Payment Instrument
+         * @description The base definition for any payment instrument. It links the instrument to a specific payment handler.
+         */
+        payment_instrument: {
+            /** @description A unique identifier for this instrument instance. Typically assigned by the platform for instruments it collects. For a business-owned saved instrument returned on an identity-linked response, this identifier is assigned by the business; the platform MUST treat it as an opaque, business-scoped reference, and the business resolves it server-side when the buyer selects it. */
+            id: string;
+            /** @description The unique identifier for the handler instance that produced this instrument. This corresponds to the 'id' field in the Payment Handler definition. */
+            handler_id: string;
+            /** @description The broad category of the instrument (e.g., 'card', 'tokenized_card'). Specific schemas will constrain this to a constant value. */
+            type: string;
+            /** @description The billing address associated with this payment method. */
+            billing_address?: components["schemas"]["postal_address"];
+            credential?: components["schemas"]["payment_credential"];
+            /** @description Display information for this payment instrument. Each payment instrument schema defines its specific display properties, as outlined by the payment handler. */
+            display?: Record<string, never>;
+            $defs: {
+                /**
+                 * Selected Payment Instrument
+                 * @description A payment instrument with selection state.
+                 */
+                selected_payment_instrument: components["schemas"]["payment_instrument"] & {
+                    /** @description Whether this instrument is selected by the user. */
+                    selected?: boolean;
+                };
+            };
+        } & {
+            [key: string]: unknown;
+        };
+        /**
+         * Selected Payment Instrument
+         * @description A payment instrument with selection state.
+         */
+        selected_payment_instrument: components["schemas"]["payment_instrument"] & {
+            /** @description Whether this instrument is selected by the user. */
+            selected?: boolean;
+        };
+        /**
+         * Order Confirmation
+         * @description Order details available at the time of checkout completion.
+         */
+        order_confirmation: {
+            /** @description Unique order identifier. */
+            id: string;
+            /** @description Human-readable label for identifying the order. MUST only be provided by the business. */
+            label?: string;
+            /**
+             * Format: uri
+             * @description Permalink to access the order on merchant site.
+             */
+            permalink_url: string;
+        };
+        /** @description UCP metadata with status 'error'. Use for response branches that carry error information. */
+        error: components["schemas"]["ucp_$defs-base"] & {
+            /** @constant */
+            status: "error";
+        };
+        /**
+         * Error Response
+         * @description Generic error response when business logic prevents resource creation or failed to retrieve resource. Used when no valid resource can be established.
+         */
+        error_response: {
+            /** @description UCP protocol metadata. Status MUST be 'error' for error response. */
+            ucp: components["schemas"]["error"];
+            /** @description Array of messages describing why the operation failed. */
+            messages: components["schemas"]["message"][];
+            /**
+             * Format: uri
+             * @description URL for buyer handoff or session recovery.
+             */
+            continue_url?: string;
+        };
+        /**
+         * UCP Cart Response Schema
+         * @description UCP metadata for cart responses. No payment handlers needed pre-checkout.
+         */
+        response_cart_schema: components["schemas"]["ucp_$defs-base"] & {
+            capabilities?: {
+                [key: string]: unknown;
+            };
+        };
+        /**
+         * Price Filter
+         * @description Price range filter denominated in context.currency. When context.currency matches the presentment currency, businesses apply the filter directly. When it differs, businesses SHOULD convert filter values to the presentment currency before applying; if conversion is not supported, businesses MAY ignore the filter and SHOULD indicate this via a message. When context.currency is absent, filter denomination is ambiguous and businesses MAY ignore it.
+         */
+        price_filter: {
+            /** @description Minimum price in ISO 4217 minor units. */
+            min?: components["schemas"]["amount"];
+            /** @description Maximum price in ISO 4217 minor units. */
+            max?: components["schemas"]["amount"];
+        };
+        /**
+         * Search Filters
+         * @description Filter criteria to narrow search results. All specified filters combine with AND logic.
+         */
+        search_filters: {
+            /** @description Filter by product categories (OR logic — matches products in any listed categories). Values match against the value field in product category entries. Valid values can be discovered from the categories field in search results, merchant documentation, or standard taxonomies that businesses may align with. */
+            categories?: string[];
+            price?: components["schemas"]["price_filter"];
+        } & {
+            [key: string]: unknown;
+        };
+        /** @description Pagination parameters for requests. */
+        request: {
+            /** @description Opaque cursor from previous response. */
+            cursor?: string;
+            /** @description Requested page size, not a guaranteed result count. When omitted, the Business MUST apply a default page size. A default of 10 is RECOMMENDED, but the Business MAY choose another value. The Business MAY return fewer results than the requested or default page size, including when enforcing its maximum page size. A Platform MUST NOT assume that the response count equals either value. */
+            limit?: number;
+        };
+        search_request: {
+            /** @description Free-text search query. */
+            query?: string;
+            context?: components["schemas"]["context"];
+            signals?: components["schemas"]["signals"];
+            attribution?: components["schemas"]["attribution"];
+            filters?: components["schemas"]["search_filters"];
+            pagination?: components["schemas"]["request"];
+        };
+        /**
+         * UCP Catalog Response Schema
+         * @description UCP metadata for catalog responses.
+         */
+        response_catalog_schema: components["schemas"]["ucp_$defs-base"] & {
+            capabilities?: {
+                [key: string]: unknown;
+            };
+        };
+        /**
+         * Category
+         * @description A product category with optional taxonomy identifier.
+         */
+        category: {
+            /** @description Category value or path (e.g., 'Apparel > Shirts', '1604'). */
+            value: string;
+            /** @description Source taxonomy. Well-known values: `google_product_category`, `shopify`, `merchant`. */
+            taxonomy?: string;
+        };
+        /**
+         * Price
+         * @description Price with explicit currency.
+         */
+        price: {
+            /** @description Amount in ISO 4217 minor units. Use 0 for free items. */
+            amount: components["schemas"]["amount"];
+            /** @description ISO 4217 currency code (e.g., 'USD', 'EUR', 'GBP'). */
+            currency: string;
+        };
+        /**
+         * Price Range
+         * @description A price range representing minimum and maximum values (e.g., a common example in retail shopping is when prices vary across product variants).
+         */
+        price_range: {
+            /** @description Minimum price in the range. */
+            min: components["schemas"]["price"];
+            /** @description Maximum price in the range. */
+            max: components["schemas"]["price"];
+        };
+        /**
+         * Media
+         * @description Media item (image, video, etc.).
+         */
+        media: {
+            /** @description Media type. Well-known values: `image`, `video`, `model_3d`. */
+            type: string;
+            /**
+             * Format: uri
+             * @description URL to the media resource.
+             */
+            url: string;
+            /** @description Accessibility text describing the media. */
+            alt_text?: string;
+            /** @description Width in pixels (for images/video). */
+            width?: number;
+            /** @description Height in pixels (for images/video). */
+            height?: number;
+        };
+        /**
+         * Option Value
+         * @description A selectable value for a product option.
+         */
+        option_value: {
+            /** @description Optional server-assigned identifier for this option value. When present in a selected_option, the server SHOULD use it for matching instead of label. */
+            id?: string;
+            /** @description Display text for this option value (e.g., 'Small', 'Blue'). */
+            label: string;
+        };
+        /**
+         * Product Option
+         * @description A product option such as size, color, or material.
+         */
+        product_option: {
+            /** @description Option name (e.g., 'Size', 'Color'). */
+            name: string;
+            /** @description Available values for this option. */
+            values: components["schemas"]["option_value"][];
+        };
+        /**
+         * Availability
+         * @description Availability of an item: whether it can be obtained, and a qualifying status.
+         */
+        availability: {
+            /** @description Whether this can be obtained. See status for fulfillment details. */
+            available?: boolean;
+            /** @description Qualifies available with fulfillment state. Well-known values: `in_stock`, `backorder`, `preorder`, `out_of_stock`, `discontinued`. */
+            status?: string;
+        };
+        /**
+         * Selected Option
+         * @description A specific option selection on a variant (e.g., Size: Large).
+         */
+        selected_option: {
+            /** @description Option name (e.g., 'Size'). */
+            name: string;
+            /** @description Optional option value identifier from option_value.id. When present, the server SHOULD use it for matching; name and label remain required for display. */
+            id?: string;
+            /** @description Selected option label (e.g., 'Large'). */
+            label: string;
+        };
+        /**
+         * Rating
+         * @description Product rating aggregate.
+         */
+        rating: {
+            /** @description Average rating value. */
+            value: number;
+            /**
+             * @description Minimum value on the rating scale (e.g., 1 for 1-5 stars).
+             * @default 1
+             */
+            scale_min: number;
+            /** @description Maximum value on the rating scale (e.g., 5 for 5-star). */
+            scale_max: number;
+            /** @description Number of reviews contributing to the rating. */
+            count?: number;
+        };
+        /**
+         * Variant
+         * @description A purchasable variant of a product with specific option selections.
+         */
+        variant: {
+            /** @description Global ID (GID) uniquely identifying this variant. Used as item.id in checkout. */
+            id: string;
+            /** @description Business-assigned identifier for inventory and fulfillment. */
+            sku?: string;
+            /** @description Industry-standard product identifiers for cross-reference and correlation. */
+            barcodes?: {
+                /** @description Barcode standard. Well-known values: UPC, EAN, ISBN, GTIN, JAN. */
+                type: string;
+                /** @description Barcode value. */
+                value: string;
+            }[];
+            /** @description URL-safe variant handle/slug. */
+            handle?: string;
+            /** @description Variant display title (e.g., 'Blue / Large'). */
+            title: string;
+            /** @description Variant description in one or more formats. */
+            description: components["schemas"]["description"];
+            /**
+             * Format: uri
+             * @description Canonical variant page URL.
+             */
+            url?: string;
+            /** @description Variant categories with optional taxonomy identifiers. */
+            categories?: components["schemas"]["category"][];
+            /** @description Current selling price. Price is the amount per one whole `quantity_unit.unit` (for example, per lb or per hour); when `quantity_unit` is absent, it is per `each`. Line total is `price × quantity × 10^-scale`, computed and rounded once by the Business; `totals` remain authoritative. */
+            price: components["schemas"]["price"];
+            /** @description Sale basis this variant's `quantity` is denominated in. The default sale basis is `each`, whose machine identity is (`C62`, 0); `C62` is the UN/CEFACT Rec20 code for one/each. An absent catalog descriptor encodes that default. An `increment` advertises the ordering granularity in steps (for example, `scale` 2 with `increment` 25 sells in 0.25-unit multiples). */
+            quantity_unit?: components["schemas"]["quantity_unit"];
+            /** @description List price before discounts (for strikethrough display). */
+            list_price?: components["schemas"]["price"];
+            /** @description Price per standard unit of measurement, for shelf-style comparison display. MAY be omitted when unit pricing does not apply. */
+            unit_price?: components["schemas"]["unit_price"];
+            /** @description Variant availability for purchase. */
+            availability?: components["schemas"]["availability"];
+            /** @description Option values that define this variant (e.g., Color: Blue, Size: Large). */
+            options?: components["schemas"]["selected_option"][];
+            /** @description Variant media (images, videos, 3D models). First item is the featured media for listings. */
+            media?: components["schemas"]["media"][];
+            /** @description Variant rating. */
+            rating?: components["schemas"]["rating"];
+            /** @description Variant tags for categorization and search. */
+            tags?: string[];
+            /** @description Business-defined custom data extending the standard variant model. */
+            metadata?: Record<string, never>;
+            /** @description Optional seller context for this variant. */
+            seller?: {
+                /** @description Seller display name. */
+                name?: string;
+                /** @description Seller policy and information links. */
+                links?: components["schemas"]["link"][];
+            };
+        };
+        /**
+         * Product
+         * @description A product in the catalog with variants and options.
+         */
+        product: {
+            /** @description Global ID (GID) uniquely identifying this product. */
+            id: string;
+            /** @description URL-safe slug for SEO-friendly URLs (e.g., 'blue-runner-pro'). Use id for stable API references. */
+            handle?: string;
+            /** @description Product title. */
+            title: string;
+            /** @description Product description in one or more formats. */
+            description: components["schemas"]["description"];
+            /**
+             * Format: uri
+             * @description Canonical product page URL.
+             */
+            url?: string;
+            /** @description Product categories with optional taxonomy identifiers. */
+            categories?: components["schemas"]["category"][];
+            /** @description Price range across all variants. */
+            price_range: components["schemas"]["price_range"];
+            /** @description List price range before discounts (for strikethrough display). */
+            list_price_range?: components["schemas"]["price_range"];
+            /** @description Product media (images, videos, 3D models). First item is the featured media for listings. */
+            media?: components["schemas"]["media"][];
+            /** @description Product options (Size, Color, etc.). */
+            options?: components["schemas"]["product_option"][];
+            /** @description Purchasable variants of this product. First item is the featured variant for listings. */
+            variants: components["schemas"]["variant"][];
+            /** @description Aggregate product rating. */
+            rating?: components["schemas"]["rating"];
+            /** @description Product tags for categorization and search. */
+            tags?: string[];
+            /** @description Business-defined custom data extending the standard product model. */
+            metadata?: Record<string, never>;
+        };
+        /** @description Pagination information in responses. */
+        response: {
+            /** @description Cursor to fetch the next page of results. MUST be present when has_next_page is true. */
+            cursor?: string;
+            /** @description Whether more results are available. */
+            has_next_page: boolean;
+            /** @description Total number of matching items, if available. */
+            total_count?: number;
+        };
+        search_response: {
+            ucp: components["schemas"]["response_catalog_schema"];
+            /** @description Products matching the search criteria. */
+            products: components["schemas"]["product"][];
+            pagination?: components["schemas"]["response"];
+            /** @description Outstanding extension-defined Actions for this catalog search response. */
+            actions?: components["schemas"]["actions"];
+            /** @description Errors, warnings, or informational messages about the search results. */
+            messages?: components["schemas"]["message"][];
+            /** @description Policies (e.g., return/refund terms) that apply to the products in these search results. `applies_to` targets are relative to the response root; when absent or empty, refer to the URLs in `links[]`. */
+            policies?: components["schemas"]["policy"][];
+        };
+        /** @description Request body for catalog lookup. */
+        lookup_request: {
+            /** @description Identifiers to lookup. Implementations MUST support product ID and variant ID; MAY support secondary identifiers (SKU, handle, etc.). */
+            ids: string[];
+            /** @description Filter criteria to narrow returned products and variants. All specified filters combine with AND logic. */
+            filters?: components["schemas"]["search_filters"];
+            context?: components["schemas"]["context"];
+            signals?: components["schemas"]["signals"];
+            attribution?: components["schemas"]["attribution"];
+        };
+        /**
+         * Input Correlation
+         * @description Maps a request identifier to the variant it resolved to, with match semantics.
+         */
+        input_correlation: {
+            /** @description The identifier from the lookup request that resolved to this variant. */
+            id: string;
+            /**
+             * @description How the request identifier resolved to this variant. Well-known values: `exact` (input directly identifies this variant, e.g., variant ID, SKU), `featured` (server selected this variant as representative, e.g., product ID resolved to best match). Businesses MAY implement and provide additional resolution strategies.
+             * @example exact
+             * @example featured
+             */
+            match?: string;
+        };
+        /** @description Variant with required correlation metadata for lookup responses. */
+        lookup_variant: components["schemas"]["variant"] & {
+            /** @description Which request identifiers resolved to this variant, and how. Each entry maps a request ID to its match type. */
+            inputs: components["schemas"]["input_correlation"][];
+        };
+        lookup_response: {
+            ucp: components["schemas"]["response_catalog_schema"];
+            /** @description Products matching the requested identifiers. May contain fewer items if some identifiers not found, or more if identifiers match multiple products. */
+            products: (components["schemas"]["product"] & {
+                variants?: unknown;
+            })[];
+            /** @description Outstanding extension-defined Actions for this catalog lookup response. */
+            actions?: components["schemas"]["actions"];
+            /** @description Errors, warnings, or informational messages about the requested items. */
+            messages?: components["schemas"]["message"][];
+            /** @description Policies (e.g., return/refund terms) that apply to the products in this response. `applies_to` targets are relative to the response root; when absent or empty, refer to the URLs in `links[]`. */
+            policies?: components["schemas"]["policy"][];
+        };
+        /**
+         * UCP Order Response Schema
+         * @description UCP metadata for order responses. No payment handlers needed post-purchase.
+         */
+        response_order_schema: components["schemas"]["ucp_$defs-base"] & {
+            capabilities?: {
+                [key: string]: unknown;
+            };
+        };
+        /** Order Line Item */
+        order_line_item: {
+            /** @description Line item identifier. */
+            id: string;
+            /** @description Purchased item data, including identity, price, and sale basis. */
+            item: components["schemas"]["item"];
+            /** @description Tracks the line item's original, current active, and fulfilled quantities. All three values use the same inherited `item.quantity_unit`. When `item.quantity_unit` is absent on an authoritative order response, each step is one whole item (`each`) under the shared default. */
+            quantity: {
+                /** @description Quantity from the original checkout, expressed as an integer step count. */
+                original?: number;
+                /** @description Current active quantity after returns, cancellations, or other order changes, expressed as an integer step count. */
+                total: number;
+                /** @description Quantity fulfilled so far, expressed as an integer step count. */
+                fulfilled: number;
+            };
+            /** @description Line item totals breakdown. */
+            totals: components["schemas"]["total"][];
+            /**
+             * @description Derived status: removed if quantity.total == 0, fulfilled if quantity.total > 0 and quantity.fulfilled == quantity.total, partial if quantity.total > 0 and quantity.fulfilled > 0, otherwise processing.
+             * @enum {string}
+             */
+            status: "processing" | "partial" | "fulfilled" | "removed";
+            /** @description Parent line item identifier for any nested structures. */
+            parent_id?: string;
+        };
+        /**
+         * Expectation
+         * @description Buyer-facing fulfillment expectation representing logical groupings of items (e.g., 'package'). Can be split, merged, or adjusted post-order to set buyer expectations for when/how items arrive.
+         */
+        expectation: {
+            /** @description Expectation identifier. */
+            id: string;
+            /** @description Which line items and quantities are in this expectation. */
+            line_items: {
+                /** @description Line item ID reference. */
+                id: string;
+                /** @description Integer count of steps of the referenced line item's `quantity_unit` (`10^-scale` × `unit`); when `quantity_unit` is absent, it counts whole items (`each`). */
+                quantity: number;
+            }[];
+            /** @description Delivery method type. Well-known values: `shipping`, `pickup`, `digital`; additional values MAY be used. */
+            method_type: string;
+            /** @description Delivery destination address. */
+            destination: components["schemas"]["postal_address"];
+            /** @description Human-readable delivery description (e.g., 'Arrives in 5-8 business days'). */
+            description?: string;
+            /** @description When this expectation can be fulfilled: 'now' or ISO 8601 timestamp for future date (backorder, pre-order). */
+            fulfillable_on?: string;
+        };
+        /**
+         * Fulfillment Event
+         * @description Append-only fulfillment event representing an actual shipment. References line items by ID.
+         */
+        fulfillment_event: {
+            /** @description Fulfillment event identifier. */
+            id: string;
+            /**
+             * Format: date-time
+             * @description RFC 3339 timestamp when this fulfillment event occurred.
+             */
+            occurred_at: string;
+            /** @description Fulfillment event type. Common values include: processing (preparing to ship), shipped (handed to carrier), in_transit (in delivery network), delivered (received by buyer), failed_attempt (delivery attempt failed), canceled (fulfillment canceled), undeliverable (cannot be delivered), returned_to_sender (returned to merchant). */
+            type: string;
+            /** @description Which line items and quantities are fulfilled in this event. */
+            line_items: {
+                /** @description Line item ID reference. */
+                id: string;
+                /** @description Integer count of steps of the referenced line item's `quantity_unit` (`10^-scale` × `unit`); when `quantity_unit` is absent, it counts whole items (`each`). */
+                quantity: number;
+            }[];
+            /** @description Carrier tracking number (required if type != processing). */
+            tracking_number?: string;
+            /**
+             * Format: uri
+             * @description URL to track this shipment (required if type != processing).
+             */
+            tracking_url?: string;
+            /** @description Carrier name (e.g., 'FedEx', 'USPS'). */
+            carrier?: string;
+            /** @description Human-readable description of the shipment status or delivery information (e.g., 'Delivered to front door', 'Out for delivery'). */
+            description?: string;
+        };
+        /**
+         * Adjustment
+         * @description Post-order event that exists independently of fulfillment. Typically represents money movements but can be any post-order change. Polymorphic type that can optionally reference line items.
+         */
+        adjustment: {
+            /** @description Adjustment event identifier. */
+            id: string;
+            /** @description Type of adjustment (open string). Typically money-related like: refund, return, credit, price_adjustment, dispute, cancellation. Can be any value that makes sense for the merchant's business. */
+            type: string;
+            /**
+             * Format: date-time
+             * @description RFC 3339 timestamp when this adjustment occurred.
+             */
+            occurred_at: string;
+            /**
+             * @description Adjustment status.
+             * @enum {string}
+             */
+            status: "pending" | "completed" | "failed";
+            /** @description Which line items and quantities are affected (optional). */
+            line_items?: {
+                /** @description Line item ID reference. */
+                id: string;
+                /** @description Signed integer count of steps of the referenced line item's `quantity_unit` (`10^-scale` × `unit`); when `quantity_unit` is absent, it counts whole items (`each`). Negative values represent reductions (e.g. returns); positive values represent additions (e.g. exchanges). */
+                quantity: number;
+                /** @description The settled measurement this adjustment reconciles (for example, actual picked weight), present when the line's price settles by measurement. Its unit identity MUST match the line's pricing basis (`item.unit_price` measure/reference unit); no unit conversion. A pure price settlement uses `quantity: 0` together with `measure` and a totals delta. */
+                measure?: components["schemas"]["measure"];
+            }[];
+            /** @description Adjustment totals breakdown. Signed values - negative for money returned to buyer (refunds, credits), positive for additional charges (exchanges). */
+            totals?: components["schemas"]["total"][];
+            /** @description Human-readable reason or description (e.g., 'Defective item', 'Customer requested'). */
+            description?: string;
+        };
+        /** @description Request body for single-product retrieval. Supports interactive variant narrowing via selected and preferences. */
+        get_product_request: {
+            /** @description Product or variant identifier. Implementations MUST support product ID and variant ID. */
+            id: string;
+            /** @description Partial or full option selections for interactive variant narrowing. When provided, response option values include availability signals (available, exists) relative to these selections. */
+            selected?: components["schemas"]["selected_option"][];
+            /** @description Option names in relaxation priority order. When no exact variant matches all selections, the server drops options from the end of this list first. E.g., ['Color', 'Size'] keeps Color and relaxes Size. */
+            preferences?: string[];
+            /** @description Filter criteria to narrow returned variants. All specified filters combine with AND logic. */
+            filters?: components["schemas"]["search_filters"];
+            context?: components["schemas"]["context"];
+            signals?: components["schemas"]["signals"];
+            attribution?: components["schemas"]["attribution"];
+        };
+        /**
+         * Detail Option Value
+         * @description An option value with availability signals relative to the current selections. Used in get_product responses where selected context exists.
+         */
+        detail_option_value: {
+            /** @description Whether a variant matching this value and the current option selections is purchasable. */
+            available?: boolean;
+            /** @description Whether a variant matching this value and the current option selections exists in the catalog. */
+            exists?: boolean;
+        } & components["schemas"]["option_value"];
+        /** @description A product in a get_product response, extended with effective selections and availability signals on option values. */
+        detail_product: {
+            /** @description Effective option selections that anchor the featured variant and availability signals. Required when the product has configurable options; may be empty or omitted for products with no option axes. */
+            selected?: components["schemas"]["selected_option"][];
+            /** @description Product options with availability signals relative to the effective selections. */
+            options?: {
+                name: string;
+                values: components["schemas"]["detail_option_value"][];
+            }[];
+        } & components["schemas"]["product"];
+        get_product_response: {
+            ucp: components["schemas"]["response_catalog_schema"];
+            /** @description The requested product with full detail. Singular — this is a single-resource operation. */
+            product: components["schemas"]["detail_product"];
+            /** @description Outstanding extension-defined Actions for this product response. */
+            actions?: components["schemas"]["actions"];
+            /** @description Warnings or informational messages about the product (e.g., price recently changed, limited availability). */
+            messages?: components["schemas"]["message"][];
+            /** @description Policies (e.g., return/refund terms) that apply to this product. `applies_to` targets are relative to the response root; when absent or empty, refer to the URLs in `links[]`. */
+            policies?: components["schemas"]["policy"][];
+        };
+        /** @description Version range requirement with minimum and optional maximum. */
+        version_constraint: {
+            /** @description Minimum required version (inclusive). */
+            min: components["schemas"]["version"];
+            /** @description Maximum compatible version (inclusive). When absent, no upper bound. */
+            max?: components["schemas"]["version"];
+        } & {
+            [key: string]: unknown;
+        };
+        /**
+         * Request Constraints
+         * @description Binds the shared Constraint Expression grammar to data in the next UCP request to the same resource.
+         */
+        request_constraints: {
+            /** @description A complete RFC 9535 JSONPath query evaluated against the next logical UCP request to the same resource. */
+            path?: string;
+            /** @description Property names required by the constrained object. Must be non-empty: an empty array applies no constraint. */
+            required?: string[];
+            /** @description Constraints keyed by property name. Must be non-empty: an empty object applies no constraint. */
+            properties?: {
+                [key: string]: components["schemas"]["constraint_expression"] | components["schemas"]["value_constraint"];
+            };
+            /** @description Alternative Object Constraints. The constrained object must satisfy at least one. A branch must be non-empty: an empty branch is satisfied by every object and neutralizes the alternation. */
+            anyOf?: components["schemas"]["constraint_expression"][];
+        };
+        /**
+         * Service (Platform Schema)
+         * @description Full service declaration for platform-level discovery. All transports require `version`, `spec`, and `transport`. REST, MCP, and embedded additionally require `schema`.
+         */
+        platform_schema: components["schemas"]["base"] & unknown & ({
+            /** @constant */
+            transport?: "rest";
+        } | {
+            /** @constant */
+            transport?: "mcp";
+        } | {
+            /** @constant */
+            transport?: "a2a";
+        } | {
+            /** @constant */
+            transport?: "embedded";
+        });
+        /**
+         * Capability (Platform Schema)
+         * @description Full capability declaration for platform-level discovery. Includes spec/schema URLs for agent fetching.
+         */
+        "$defs-platform_schema": components["schemas"]["$defs-base"] & unknown;
+        /**
+         * Payment Handler (Platform Schema)
+         * @description Platform declaration for discovery profiles. May include partial config state required for discovery.
+         */
+        "payment_handler_$defs-platform_schema": components["schemas"]["payment_handler_$defs-base"] & unknown;
+        /**
+         * Service (Business Schema)
+         * @description Service binding for business/merchant configuration. May override platform endpoints.
+         */
+        business_schema: components["schemas"]["base"] & ({
+            /** @constant */
+            transport?: "rest";
+        } | {
+            /** @constant */
+            transport?: "mcp";
+        } | {
+            /** @constant */
+            transport?: "a2a";
+        } | {
+            /** @constant */
+            transport?: "embedded";
+            config?: components["schemas"]["embedded_config"];
+        });
+        /**
+         * Capability (Business Schema)
+         * @description Capability declaration for business/merchant discovery. Requires the `schema` URL so platforms can fetch and compose it during negotiation; may also include business-specific config overrides.
+         */
+        "$defs-business_schema": components["schemas"]["$defs-base"] & unknown;
+        /**
+         * Payment Handler (Business Schema)
+         * @description Business declaration for discovery profiles. May include partial config state required for discovery.
+         */
+        "payment_handler_$defs-business_schema": components["schemas"]["payment_handler_$defs-base"];
+    };
+    responses: never;
+    parameters: {
+        /** @description The unique identifier of the checkout session. */
+        checkout_session_id_path: string;
+        /** @description The unique identifier of the cart. */
+        cart_id_path: string;
+        /** @description The unique identifier of the order. */
+        order_id_path: string;
+        /** @description Should contain oauth token representing the following 2 schemes: 1. Platform self authenticating (client_credentials). 2. Platform authenticating on behalf of end user (authorization_code). */
+        authorization: string;
+        /** @description Authenticates the platform with a reusable api key allocated to the platform by the business. */
+        x_api_key: string;
+        /** @description RFC 9421 HTTP Message Signature. Required when using HTTP Message Signatures for authentication. Format: `sig1=:<base64-signature>:`. */
+        signature: string;
+        /** @description RFC 9421 Signature-Input header. Required when using HTTP Message Signatures for authentication. Format: `sig1=("@method" "@path" ...);created=<timestamp>;keyid="<key-id>"`. */
+        signature_input: string;
+        /** @description Body digest per RFC 9530. Required for requests/responses with a body. Format: `sha-256=:<base64-digest>:`. */
+        content_digest: string;
+        /** @description Ensures duplicate operations don't happen during retries. */
+        idempotency_key: string;
+        /** @description For tracing the requests across network layers and components. */
+        request_id: string;
+        /** @description Identifies the user agent string making the call. */
+        user_agent: string;
+        /** @description Identifies the UCP agent making the call. All requests MUST include the UCP-Agent header containing the signer's profile URI using RFC 8941 Dictionary syntax. The URL MUST point to /.well-known/ucp. Format: profile="https://example.com/.well-known/ucp". */
+        ucp_agent: string;
+        /** @description Representation Metadata. Tells the receiver what the data in the message body actually is. */
+        content_type: string;
+        /** @description Content Negotiation. The client tells the server what data formats it is capable of understanding. */
+        accept: string;
+        /** @description Localization. Tells the receiver the user's preferred natural languages, often with "weights" or priorities. */
+        accept_language: string;
+        /** @description Compression. The client tells the server which content-codings it supports, usually for compression. */
+        accept_encoding: string;
+        /** @description Webhook event occurrence unix timestamp (seconds since epoch). */
+        webhook_timestamp: number;
+        /** @description The unique identifier of a webhook event. */
+        webhook_id: string;
+    };
+    requestBodies: never;
+    headers: {
+        /** @description RFC 9421 HTTP Message Signature for response. Contains the signature value in the format `sig1=:<base64-signature>:`. */
+        signature: string;
+        /** @description RFC 9421 Signature-Input header for response. Describes signed components, timestamp, and key ID. */
+        signature_input: string;
+        /** @description JCS-canonicalized body digest per RFC 8785. Format: `sha-256=:<base64-digest>:`. */
+        content_digest: string;
+    };
+    pathItems: never;
+}
+export type $defs = Record<string, never>;
+export interface operations {
+    create_checkout: {
+        parameters: {
+            query?: never;
+            header: {
+                /** @description Should contain oauth token representing the following 2 schemes: 1. Platform self authenticating (client_credentials). 2. Platform authenticating on behalf of end user (authorization_code). */
+                Authorization?: components["parameters"]["authorization"];
+                /** @description Authenticates the platform with a reusable api key allocated to the platform by the business. */
+                "X-API-Key"?: components["parameters"]["x_api_key"];
+                /** @description RFC 9421 HTTP Message Signature. Required when using HTTP Message Signatures for authentication. Format: `sig1=:<base64-signature>:`. */
+                Signature?: components["parameters"]["signature"];
+                /** @description RFC 9421 Signature-Input header. Required when using HTTP Message Signatures for authentication. Format: `sig1=("@method" "@path" ...);created=<timestamp>;keyid="<key-id>"`. */
+                "Signature-Input"?: components["parameters"]["signature_input"];
+                /** @description Body digest per RFC 9530. Required for requests/responses with a body. Format: `sha-256=:<base64-digest>:`. */
+                "Content-Digest"?: components["parameters"]["content_digest"];
+                /** @description Ensures duplicate operations don't happen during retries. */
+                "Idempotency-Key": components["parameters"]["idempotency_key"];
+                /** @description For tracing the requests across network layers and components. */
+                "Request-Id": components["parameters"]["request_id"];
+                /** @description Identifies the user agent string making the call. */
+                "User-Agent"?: components["parameters"]["user_agent"];
+                /** @description Identifies the UCP agent making the call. All requests MUST include the UCP-Agent header containing the signer's profile URI using RFC 8941 Dictionary syntax. The URL MUST point to /.well-known/ucp. Format: profile="https://example.com/.well-known/ucp". */
+                "UCP-Agent": components["parameters"]["ucp_agent"];
+                /** @description Representation Metadata. Tells the receiver what the data in the message body actually is. */
+                "Content-Type"?: components["parameters"]["content_type"];
+                /** @description Content Negotiation. The client tells the server what data formats it is capable of understanding. */
+                Accept?: components["parameters"]["accept"];
+                /** @description Localization. Tells the receiver the user's preferred natural languages, often with "weights" or priorities. */
+                "Accept-Language"?: components["parameters"]["accept_language"];
+                /** @description Compression. The client tells the server which content-codings it supports, usually for compression. */
+                "Accept-Encoding"?: components["parameters"]["accept_encoding"];
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["checkout"];
+            };
+        };
+        responses: {
+            /** @description Checkout session created */
+            201: {
+                headers: {
+                    Signature: components["headers"]["signature"];
+                    "Signature-Input": components["headers"]["signature_input"];
+                    "Content-Digest": components["headers"]["content_digest"];
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["checkout_response"];
+                };
+            };
+        };
+    };
+    get_checkout: {
+        parameters: {
+            query?: never;
+            header: {
+                /** @description Should contain oauth token representing the following 2 schemes: 1. Platform self authenticating (client_credentials). 2. Platform authenticating on behalf of end user (authorization_code). */
+                Authorization?: components["parameters"]["authorization"];
+                /** @description Authenticates the platform with a reusable api key allocated to the platform by the business. */
+                "X-API-Key"?: components["parameters"]["x_api_key"];
+                /** @description RFC 9421 HTTP Message Signature. Required when using HTTP Message Signatures for authentication. Format: `sig1=:<base64-signature>:`. */
+                Signature?: components["parameters"]["signature"];
+                /** @description RFC 9421 Signature-Input header. Required when using HTTP Message Signatures for authentication. Format: `sig1=("@method" "@path" ...);created=<timestamp>;keyid="<key-id>"`. */
+                "Signature-Input"?: components["parameters"]["signature_input"];
+                /** @description For tracing the requests across network layers and components. */
+                "Request-Id": components["parameters"]["request_id"];
+                /** @description Identifies the user agent string making the call. */
+                "User-Agent"?: components["parameters"]["user_agent"];
+                /** @description Identifies the UCP agent making the call. All requests MUST include the UCP-Agent header containing the signer's profile URI using RFC 8941 Dictionary syntax. The URL MUST point to /.well-known/ucp. Format: profile="https://example.com/.well-known/ucp". */
+                "UCP-Agent": components["parameters"]["ucp_agent"];
+                /** @description Representation Metadata. Tells the receiver what the data in the message body actually is. */
+                "Content-Type"?: components["parameters"]["content_type"];
+                /** @description Content Negotiation. The client tells the server what data formats it is capable of understanding. */
+                Accept?: components["parameters"]["accept"];
+                /** @description Localization. Tells the receiver the user's preferred natural languages, often with "weights" or priorities. */
+                "Accept-Language"?: components["parameters"]["accept_language"];
+                /** @description Compression. The client tells the server which content-codings it supports, usually for compression. */
+                "Accept-Encoding"?: components["parameters"]["accept_encoding"];
+            };
+            path: {
+                /** @description The unique identifier of the checkout session. */
+                id: components["parameters"]["checkout_session_id_path"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Checkout session retrieved */
+            200: {
+                headers: {
+                    Signature: components["headers"]["signature"];
+                    "Signature-Input": components["headers"]["signature_input"];
+                    "Content-Digest": components["headers"]["content_digest"];
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["checkout_response"];
+                };
+            };
+        };
+    };
+    update_checkout: {
+        parameters: {
+            query?: never;
+            header: {
+                /** @description Should contain oauth token representing the following 2 schemes: 1. Platform self authenticating (client_credentials). 2. Platform authenticating on behalf of end user (authorization_code). */
+                Authorization?: components["parameters"]["authorization"];
+                /** @description Authenticates the platform with a reusable api key allocated to the platform by the business. */
+                "X-API-Key"?: components["parameters"]["x_api_key"];
+                /** @description RFC 9421 HTTP Message Signature. Required when using HTTP Message Signatures for authentication. Format: `sig1=:<base64-signature>:`. */
+                Signature?: components["parameters"]["signature"];
+                /** @description RFC 9421 Signature-Input header. Required when using HTTP Message Signatures for authentication. Format: `sig1=("@method" "@path" ...);created=<timestamp>;keyid="<key-id>"`. */
+                "Signature-Input"?: components["parameters"]["signature_input"];
+                /** @description Body digest per RFC 9530. Required for requests/responses with a body. Format: `sha-256=:<base64-digest>:`. */
+                "Content-Digest"?: components["parameters"]["content_digest"];
+                /** @description Ensures duplicate operations don't happen during retries. */
+                "Idempotency-Key": components["parameters"]["idempotency_key"];
+                /** @description For tracing the requests across network layers and components. */
+                "Request-Id": components["parameters"]["request_id"];
+                /** @description Identifies the user agent string making the call. */
+                "User-Agent"?: components["parameters"]["user_agent"];
+                /** @description Identifies the UCP agent making the call. All requests MUST include the UCP-Agent header containing the signer's profile URI using RFC 8941 Dictionary syntax. The URL MUST point to /.well-known/ucp. Format: profile="https://example.com/.well-known/ucp". */
+                "UCP-Agent": components["parameters"]["ucp_agent"];
+                /** @description Representation Metadata. Tells the receiver what the data in the message body actually is. */
+                "Content-Type"?: components["parameters"]["content_type"];
+                /** @description Content Negotiation. The client tells the server what data formats it is capable of understanding. */
+                Accept?: components["parameters"]["accept"];
+                /** @description Localization. Tells the receiver the user's preferred natural languages, often with "weights" or priorities. */
+                "Accept-Language"?: components["parameters"]["accept_language"];
+                /** @description Compression. The client tells the server which content-codings it supports, usually for compression. */
+                "Accept-Encoding"?: components["parameters"]["accept_encoding"];
+            };
+            path: {
+                /** @description The unique identifier of the checkout session. */
+                id: components["parameters"]["checkout_session_id_path"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["checkout"];
+            };
+        };
+        responses: {
+            /** @description Current Checkout state after the Update request, whether the update was applied or rejected. */
+            200: {
+                headers: {
+                    Signature: components["headers"]["signature"];
+                    "Signature-Input": components["headers"]["signature_input"];
+                    "Content-Digest": components["headers"]["content_digest"];
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["checkout_response"];
+                };
+            };
+        };
+    };
+    complete_checkout: {
+        parameters: {
+            query?: never;
+            header: {
+                /** @description Should contain oauth token representing the following 2 schemes: 1. Platform self authenticating (client_credentials). 2. Platform authenticating on behalf of end user (authorization_code). */
+                Authorization?: components["parameters"]["authorization"];
+                /** @description Authenticates the platform with a reusable api key allocated to the platform by the business. */
+                "X-API-Key"?: components["parameters"]["x_api_key"];
+                /** @description RFC 9421 HTTP Message Signature. Required when using HTTP Message Signatures for authentication. Format: `sig1=:<base64-signature>:`. */
+                Signature?: components["parameters"]["signature"];
+                /** @description RFC 9421 Signature-Input header. Required when using HTTP Message Signatures for authentication. Format: `sig1=("@method" "@path" ...);created=<timestamp>;keyid="<key-id>"`. */
+                "Signature-Input"?: components["parameters"]["signature_input"];
+                /** @description Body digest per RFC 9530. Required for requests/responses with a body. Format: `sha-256=:<base64-digest>:`. */
+                "Content-Digest"?: components["parameters"]["content_digest"];
+                /** @description Ensures duplicate operations don't happen during retries. */
+                "Idempotency-Key": components["parameters"]["idempotency_key"];
+                /** @description For tracing the requests across network layers and components. */
+                "Request-Id": components["parameters"]["request_id"];
+                /** @description Identifies the user agent string making the call. */
+                "User-Agent"?: components["parameters"]["user_agent"];
+                /** @description Identifies the UCP agent making the call. All requests MUST include the UCP-Agent header containing the signer's profile URI using RFC 8941 Dictionary syntax. The URL MUST point to /.well-known/ucp. Format: profile="https://example.com/.well-known/ucp". */
+                "UCP-Agent": components["parameters"]["ucp_agent"];
+                /** @description Representation Metadata. Tells the receiver what the data in the message body actually is. */
+                "Content-Type"?: components["parameters"]["content_type"];
+                /** @description Content Negotiation. The client tells the server what data formats it is capable of understanding. */
+                Accept?: components["parameters"]["accept"];
+                /** @description Localization. Tells the receiver the user's preferred natural languages, often with "weights" or priorities. */
+                "Accept-Language"?: components["parameters"]["accept_language"];
+                /** @description Compression. The client tells the server which content-codings it supports, usually for compression. */
+                "Accept-Encoding"?: components["parameters"]["accept_encoding"];
+            };
+            path: {
+                /** @description The unique identifier of the checkout session. */
+                id: components["parameters"]["checkout_session_id_path"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["checkout"];
+            };
+        };
+        responses: {
+            /** @description Checkout session completed */
+            200: {
+                headers: {
+                    Signature: components["headers"]["signature"];
+                    "Signature-Input": components["headers"]["signature_input"];
+                    "Content-Digest": components["headers"]["content_digest"];
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["checkout_response"];
+                };
+            };
+        };
+    };
+    cancel_checkout: {
+        parameters: {
+            query?: never;
+            header: {
+                /** @description Should contain oauth token representing the following 2 schemes: 1. Platform self authenticating (client_credentials). 2. Platform authenticating on behalf of end user (authorization_code). */
+                Authorization?: components["parameters"]["authorization"];
+                /** @description Authenticates the platform with a reusable api key allocated to the platform by the business. */
+                "X-API-Key"?: components["parameters"]["x_api_key"];
+                /** @description RFC 9421 HTTP Message Signature. Required when using HTTP Message Signatures for authentication. Format: `sig1=:<base64-signature>:`. */
+                Signature?: components["parameters"]["signature"];
+                /** @description RFC 9421 Signature-Input header. Required when using HTTP Message Signatures for authentication. Format: `sig1=("@method" "@path" ...);created=<timestamp>;keyid="<key-id>"`. */
+                "Signature-Input"?: components["parameters"]["signature_input"];
+                /** @description Body digest per RFC 9530. Required for requests/responses with a body. Format: `sha-256=:<base64-digest>:`. */
+                "Content-Digest"?: components["parameters"]["content_digest"];
+                /** @description Ensures duplicate operations don't happen during retries. */
+                "Idempotency-Key": components["parameters"]["idempotency_key"];
+                /** @description For tracing the requests across network layers and components. */
+                "Request-Id": components["parameters"]["request_id"];
+                /** @description Identifies the user agent string making the call. */
+                "User-Agent"?: components["parameters"]["user_agent"];
+                /** @description Identifies the UCP agent making the call. All requests MUST include the UCP-Agent header containing the signer's profile URI using RFC 8941 Dictionary syntax. The URL MUST point to /.well-known/ucp. Format: profile="https://example.com/.well-known/ucp". */
+                "UCP-Agent": components["parameters"]["ucp_agent"];
+                /** @description Representation Metadata. Tells the receiver what the data in the message body actually is. */
+                "Content-Type"?: components["parameters"]["content_type"];
+                /** @description Content Negotiation. The client tells the server what data formats it is capable of understanding. */
+                Accept?: components["parameters"]["accept"];
+                /** @description Localization. Tells the receiver the user's preferred natural languages, often with "weights" or priorities. */
+                "Accept-Language"?: components["parameters"]["accept_language"];
+                /** @description Compression. The client tells the server which content-codings it supports, usually for compression. */
+                "Accept-Encoding"?: components["parameters"]["accept_encoding"];
+            };
+            path: {
+                /** @description The unique identifier of the checkout session. */
+                id: components["parameters"]["checkout_session_id_path"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Checkout session canceled */
+            200: {
+                headers: {
+                    Signature: components["headers"]["signature"];
+                    "Signature-Input": components["headers"]["signature_input"];
+                    "Content-Digest": components["headers"]["content_digest"];
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["checkout_response"];
+                };
+            };
+        };
+    };
+    create_cart: {
+        parameters: {
+            query?: never;
+            header: {
+                /** @description Should contain oauth token representing the following 2 schemes: 1. Platform self authenticating (client_credentials). 2. Platform authenticating on behalf of end user (authorization_code). */
+                Authorization?: components["parameters"]["authorization"];
+                /** @description Authenticates the platform with a reusable api key allocated to the platform by the business. */
+                "X-API-Key"?: components["parameters"]["x_api_key"];
+                /** @description RFC 9421 HTTP Message Signature. Required when using HTTP Message Signatures for authentication. Format: `sig1=:<base64-signature>:`. */
+                Signature?: components["parameters"]["signature"];
+                /** @description RFC 9421 Signature-Input header. Required when using HTTP Message Signatures for authentication. Format: `sig1=("@method" "@path" ...);created=<timestamp>;keyid="<key-id>"`. */
+                "Signature-Input"?: components["parameters"]["signature_input"];
+                /** @description Body digest per RFC 9530. Required for requests/responses with a body. Format: `sha-256=:<base64-digest>:`. */
+                "Content-Digest"?: components["parameters"]["content_digest"];
+                /** @description Ensures duplicate operations don't happen during retries. */
+                "Idempotency-Key": components["parameters"]["idempotency_key"];
+                /** @description For tracing the requests across network layers and components. */
+                "Request-Id": components["parameters"]["request_id"];
+                /** @description Identifies the user agent string making the call. */
+                "User-Agent"?: components["parameters"]["user_agent"];
+                /** @description Identifies the UCP agent making the call. All requests MUST include the UCP-Agent header containing the signer's profile URI using RFC 8941 Dictionary syntax. The URL MUST point to /.well-known/ucp. Format: profile="https://example.com/.well-known/ucp". */
+                "UCP-Agent": components["parameters"]["ucp_agent"];
+                /** @description Representation Metadata. Tells the receiver what the data in the message body actually is. */
+                "Content-Type"?: components["parameters"]["content_type"];
+                /** @description Content Negotiation. The client tells the server what data formats it is capable of understanding. */
+                Accept?: components["parameters"]["accept"];
+                /** @description Localization. Tells the receiver the user's preferred natural languages, often with "weights" or priorities. */
+                "Accept-Language"?: components["parameters"]["accept_language"];
+                /** @description Compression. The client tells the server which content-codings it supports, usually for compression. */
+                "Accept-Encoding"?: components["parameters"]["accept_encoding"];
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["cart"];
+            };
+        };
+        responses: {
+            /** @description Cart created */
+            201: {
+                headers: {
+                    Signature: components["headers"]["signature"];
+                    "Signature-Input": components["headers"]["signature_input"];
+                    "Content-Digest": components["headers"]["content_digest"];
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["cart_response"];
+                };
+            };
+        };
+    };
+    get_cart: {
+        parameters: {
+            query?: never;
+            header: {
+                /** @description Should contain oauth token representing the following 2 schemes: 1. Platform self authenticating (client_credentials). 2. Platform authenticating on behalf of end user (authorization_code). */
+                Authorization?: components["parameters"]["authorization"];
+                /** @description Authenticates the platform with a reusable api key allocated to the platform by the business. */
+                "X-API-Key"?: components["parameters"]["x_api_key"];
+                /** @description RFC 9421 HTTP Message Signature. Required when using HTTP Message Signatures for authentication. Format: `sig1=:<base64-signature>:`. */
+                Signature?: components["parameters"]["signature"];
+                /** @description RFC 9421 Signature-Input header. Required when using HTTP Message Signatures for authentication. Format: `sig1=("@method" "@path" ...);created=<timestamp>;keyid="<key-id>"`. */
+                "Signature-Input"?: components["parameters"]["signature_input"];
+                /** @description For tracing the requests across network layers and components. */
+                "Request-Id": components["parameters"]["request_id"];
+                /** @description Identifies the user agent string making the call. */
+                "User-Agent"?: components["parameters"]["user_agent"];
+                /** @description Identifies the UCP agent making the call. All requests MUST include the UCP-Agent header containing the signer's profile URI using RFC 8941 Dictionary syntax. The URL MUST point to /.well-known/ucp. Format: profile="https://example.com/.well-known/ucp". */
+                "UCP-Agent": components["parameters"]["ucp_agent"];
+                /** @description Representation Metadata. Tells the receiver what the data in the message body actually is. */
+                "Content-Type"?: components["parameters"]["content_type"];
+                /** @description Content Negotiation. The client tells the server what data formats it is capable of understanding. */
+                Accept?: components["parameters"]["accept"];
+                /** @description Localization. Tells the receiver the user's preferred natural languages, often with "weights" or priorities. */
+                "Accept-Language"?: components["parameters"]["accept_language"];
+                /** @description Compression. The client tells the server which content-codings it supports, usually for compression. */
+                "Accept-Encoding"?: components["parameters"]["accept_encoding"];
+            };
+            path: {
+                /** @description The unique identifier of the cart. */
+                id: components["parameters"]["cart_id_path"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Cart retrieved */
+            200: {
+                headers: {
+                    Signature: components["headers"]["signature"];
+                    "Signature-Input": components["headers"]["signature_input"];
+                    "Content-Digest": components["headers"]["content_digest"];
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["cart_response"];
+                };
+            };
+        };
+    };
+    update_cart: {
+        parameters: {
+            query?: never;
+            header: {
+                /** @description Should contain oauth token representing the following 2 schemes: 1. Platform self authenticating (client_credentials). 2. Platform authenticating on behalf of end user (authorization_code). */
+                Authorization?: components["parameters"]["authorization"];
+                /** @description Authenticates the platform with a reusable api key allocated to the platform by the business. */
+                "X-API-Key"?: components["parameters"]["x_api_key"];
+                /** @description RFC 9421 HTTP Message Signature. Required when using HTTP Message Signatures for authentication. Format: `sig1=:<base64-signature>:`. */
+                Signature?: components["parameters"]["signature"];
+                /** @description RFC 9421 Signature-Input header. Required when using HTTP Message Signatures for authentication. Format: `sig1=("@method" "@path" ...);created=<timestamp>;keyid="<key-id>"`. */
+                "Signature-Input"?: components["parameters"]["signature_input"];
+                /** @description Body digest per RFC 9530. Required for requests/responses with a body. Format: `sha-256=:<base64-digest>:`. */
+                "Content-Digest"?: components["parameters"]["content_digest"];
+                /** @description Ensures duplicate operations don't happen during retries. */
+                "Idempotency-Key": components["parameters"]["idempotency_key"];
+                /** @description For tracing the requests across network layers and components. */
+                "Request-Id": components["parameters"]["request_id"];
+                /** @description Identifies the user agent string making the call. */
+                "User-Agent"?: components["parameters"]["user_agent"];
+                /** @description Identifies the UCP agent making the call. All requests MUST include the UCP-Agent header containing the signer's profile URI using RFC 8941 Dictionary syntax. The URL MUST point to /.well-known/ucp. Format: profile="https://example.com/.well-known/ucp". */
+                "UCP-Agent": components["parameters"]["ucp_agent"];
+                /** @description Representation Metadata. Tells the receiver what the data in the message body actually is. */
+                "Content-Type"?: components["parameters"]["content_type"];
+                /** @description Content Negotiation. The client tells the server what data formats it is capable of understanding. */
+                Accept?: components["parameters"]["accept"];
+                /** @description Localization. Tells the receiver the user's preferred natural languages, often with "weights" or priorities. */
+                "Accept-Language"?: components["parameters"]["accept_language"];
+                /** @description Compression. The client tells the server which content-codings it supports, usually for compression. */
+                "Accept-Encoding"?: components["parameters"]["accept_encoding"];
+            };
+            path: {
+                /** @description The unique identifier of the cart. */
+                id: components["parameters"]["cart_id_path"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["cart"];
+            };
+        };
+        responses: {
+            /** @description Cart updated */
+            200: {
+                headers: {
+                    Signature: components["headers"]["signature"];
+                    "Signature-Input": components["headers"]["signature_input"];
+                    "Content-Digest": components["headers"]["content_digest"];
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["cart_response"];
+                };
+            };
+        };
+    };
+    cancel_cart: {
+        parameters: {
+            query?: never;
+            header: {
+                /** @description Should contain oauth token representing the following 2 schemes: 1. Platform self authenticating (client_credentials). 2. Platform authenticating on behalf of end user (authorization_code). */
+                Authorization?: components["parameters"]["authorization"];
+                /** @description Authenticates the platform with a reusable api key allocated to the platform by the business. */
+                "X-API-Key"?: components["parameters"]["x_api_key"];
+                /** @description RFC 9421 HTTP Message Signature. Required when using HTTP Message Signatures for authentication. Format: `sig1=:<base64-signature>:`. */
+                Signature?: components["parameters"]["signature"];
+                /** @description RFC 9421 Signature-Input header. Required when using HTTP Message Signatures for authentication. Format: `sig1=("@method" "@path" ...);created=<timestamp>;keyid="<key-id>"`. */
+                "Signature-Input"?: components["parameters"]["signature_input"];
+                /** @description Body digest per RFC 9530. Required for requests/responses with a body. Format: `sha-256=:<base64-digest>:`. */
+                "Content-Digest"?: components["parameters"]["content_digest"];
+                /** @description Ensures duplicate operations don't happen during retries. */
+                "Idempotency-Key": components["parameters"]["idempotency_key"];
+                /** @description For tracing the requests across network layers and components. */
+                "Request-Id": components["parameters"]["request_id"];
+                /** @description Identifies the user agent string making the call. */
+                "User-Agent"?: components["parameters"]["user_agent"];
+                /** @description Identifies the UCP agent making the call. All requests MUST include the UCP-Agent header containing the signer's profile URI using RFC 8941 Dictionary syntax. The URL MUST point to /.well-known/ucp. Format: profile="https://example.com/.well-known/ucp". */
+                "UCP-Agent": components["parameters"]["ucp_agent"];
+                /** @description Representation Metadata. Tells the receiver what the data in the message body actually is. */
+                "Content-Type"?: components["parameters"]["content_type"];
+                /** @description Content Negotiation. The client tells the server what data formats it is capable of understanding. */
+                Accept?: components["parameters"]["accept"];
+                /** @description Localization. Tells the receiver the user's preferred natural languages, often with "weights" or priorities. */
+                "Accept-Language"?: components["parameters"]["accept_language"];
+                /** @description Compression. The client tells the server which content-codings it supports, usually for compression. */
+                "Accept-Encoding"?: components["parameters"]["accept_encoding"];
+            };
+            path: {
+                /** @description The unique identifier of the cart. */
+                id: components["parameters"]["cart_id_path"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Cart cancelled */
+            200: {
+                headers: {
+                    Signature: components["headers"]["signature"];
+                    "Signature-Input": components["headers"]["signature_input"];
+                    "Content-Digest": components["headers"]["content_digest"];
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["cart_response"];
+                };
+            };
+        };
+    };
+    search_catalog: {
+        parameters: {
+            query?: never;
+            header: {
+                /** @description Should contain oauth token representing the following 2 schemes: 1. Platform self authenticating (client_credentials). 2. Platform authenticating on behalf of end user (authorization_code). */
+                Authorization?: components["parameters"]["authorization"];
+                /** @description Authenticates the platform with a reusable api key allocated to the platform by the business. */
+                "X-API-Key"?: components["parameters"]["x_api_key"];
+                /** @description RFC 9421 HTTP Message Signature. Required when using HTTP Message Signatures for authentication. Format: `sig1=:<base64-signature>:`. */
+                Signature?: components["parameters"]["signature"];
+                /** @description RFC 9421 Signature-Input header. Required when using HTTP Message Signatures for authentication. Format: `sig1=("@method" "@path" ...);created=<timestamp>;keyid="<key-id>"`. */
+                "Signature-Input"?: components["parameters"]["signature_input"];
+                /** @description Body digest per RFC 9530. Required for requests/responses with a body. Format: `sha-256=:<base64-digest>:`. */
+                "Content-Digest"?: components["parameters"]["content_digest"];
+                /** @description For tracing the requests across network layers and components. */
+                "Request-Id": components["parameters"]["request_id"];
+                /** @description Identifies the user agent string making the call. */
+                "User-Agent"?: components["parameters"]["user_agent"];
+                /** @description Identifies the UCP agent making the call. All requests MUST include the UCP-Agent header containing the signer's profile URI using RFC 8941 Dictionary syntax. The URL MUST point to /.well-known/ucp. Format: profile="https://example.com/.well-known/ucp". */
+                "UCP-Agent": components["parameters"]["ucp_agent"];
+                /** @description Representation Metadata. Tells the receiver what the data in the message body actually is. */
+                "Content-Type"?: components["parameters"]["content_type"];
+                /** @description Content Negotiation. The client tells the server what data formats it is capable of understanding. */
+                Accept?: components["parameters"]["accept"];
+                /** @description Localization. Tells the receiver the user's preferred natural languages, often with "weights" or priorities. */
+                "Accept-Language"?: components["parameters"]["accept_language"];
+                /** @description Compression. The client tells the server which content-codings it supports, usually for compression. */
+                "Accept-Encoding"?: components["parameters"]["accept_encoding"];
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["search_request"];
+            };
+        };
+        responses: {
+            /** @description Search results */
+            200: {
+                headers: {
+                    Signature: components["headers"]["signature"];
+                    "Signature-Input": components["headers"]["signature_input"];
+                    "Content-Digest": components["headers"]["content_digest"];
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["search_response"];
+                };
+            };
+        };
+    };
+    lookup_catalog: {
+        parameters: {
+            query?: never;
+            header: {
+                /** @description Should contain oauth token representing the following 2 schemes: 1. Platform self authenticating (client_credentials). 2. Platform authenticating on behalf of end user (authorization_code). */
+                Authorization?: components["parameters"]["authorization"];
+                /** @description Authenticates the platform with a reusable api key allocated to the platform by the business. */
+                "X-API-Key"?: components["parameters"]["x_api_key"];
+                /** @description RFC 9421 HTTP Message Signature. Required when using HTTP Message Signatures for authentication. Format: `sig1=:<base64-signature>:`. */
+                Signature?: components["parameters"]["signature"];
+                /** @description RFC 9421 Signature-Input header. Required when using HTTP Message Signatures for authentication. Format: `sig1=("@method" "@path" ...);created=<timestamp>;keyid="<key-id>"`. */
+                "Signature-Input"?: components["parameters"]["signature_input"];
+                /** @description Body digest per RFC 9530. Required for requests/responses with a body. Format: `sha-256=:<base64-digest>:`. */
+                "Content-Digest"?: components["parameters"]["content_digest"];
+                /** @description For tracing the requests across network layers and components. */
+                "Request-Id": components["parameters"]["request_id"];
+                /** @description Identifies the user agent string making the call. */
+                "User-Agent"?: components["parameters"]["user_agent"];
+                /** @description Identifies the UCP agent making the call. All requests MUST include the UCP-Agent header containing the signer's profile URI using RFC 8941 Dictionary syntax. The URL MUST point to /.well-known/ucp. Format: profile="https://example.com/.well-known/ucp". */
+                "UCP-Agent": components["parameters"]["ucp_agent"];
+                /** @description Representation Metadata. Tells the receiver what the data in the message body actually is. */
+                "Content-Type"?: components["parameters"]["content_type"];
+                /** @description Content Negotiation. The client tells the server what data formats it is capable of understanding. */
+                Accept?: components["parameters"]["accept"];
+                /** @description Localization. Tells the receiver the user's preferred natural languages, often with "weights" or priorities. */
+                "Accept-Language"?: components["parameters"]["accept_language"];
+                /** @description Compression. The client tells the server which content-codings it supports, usually for compression. */
+                "Accept-Encoding"?: components["parameters"]["accept_encoding"];
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["lookup_request"];
+            };
+        };
+        responses: {
+            /** @description Lookup result */
+            200: {
+                headers: {
+                    Signature: components["headers"]["signature"];
+                    "Signature-Input": components["headers"]["signature_input"];
+                    "Content-Digest": components["headers"]["content_digest"];
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["lookup_response"];
+                };
+            };
+        };
+    };
+    get_order: {
+        parameters: {
+            query?: never;
+            header: {
+                /** @description Should contain oauth token representing the following 2 schemes: 1. Platform self authenticating (client_credentials). 2. Platform authenticating on behalf of end user (authorization_code). */
+                Authorization?: components["parameters"]["authorization"];
+                /** @description Authenticates the platform with a reusable api key allocated to the platform by the business. */
+                "X-API-Key"?: components["parameters"]["x_api_key"];
+                /** @description RFC 9421 HTTP Message Signature. Required when using HTTP Message Signatures for authentication. Format: `sig1=:<base64-signature>:`. */
+                Signature?: components["parameters"]["signature"];
+                /** @description RFC 9421 Signature-Input header. Required when using HTTP Message Signatures for authentication. Format: `sig1=("@method" "@path" ...);created=<timestamp>;keyid="<key-id>"`. */
+                "Signature-Input"?: components["parameters"]["signature_input"];
+                /** @description For tracing the requests across network layers and components. */
+                "Request-Id": components["parameters"]["request_id"];
+                /** @description Identifies the user agent string making the call. */
+                "User-Agent"?: components["parameters"]["user_agent"];
+                /** @description Identifies the UCP agent making the call. All requests MUST include the UCP-Agent header containing the signer's profile URI using RFC 8941 Dictionary syntax. The URL MUST point to /.well-known/ucp. Format: profile="https://example.com/.well-known/ucp". */
+                "UCP-Agent": components["parameters"]["ucp_agent"];
+                /** @description Representation Metadata. Tells the receiver what the data in the message body actually is. */
+                "Content-Type"?: components["parameters"]["content_type"];
+                /** @description Content Negotiation. The client tells the server what data formats it is capable of understanding. */
+                Accept?: components["parameters"]["accept"];
+                /** @description Localization. Tells the receiver the user's preferred natural languages, often with "weights" or priorities. */
+                "Accept-Language"?: components["parameters"]["accept_language"];
+                /** @description Compression. The client tells the server which content-codings it supports, usually for compression. */
+                "Accept-Encoding"?: components["parameters"]["accept_encoding"];
+            };
+            path: {
+                /** @description The unique identifier of the order. */
+                id: components["parameters"]["order_id_path"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Order retrieved or business outcome message */
+            200: {
+                headers: {
+                    Signature: components["headers"]["signature"];
+                    "Signature-Input": components["headers"]["signature_input"];
+                    "Content-Digest": components["headers"]["content_digest"];
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["order_response"];
+                };
+            };
+        };
+    };
+    get_product: {
+        parameters: {
+            query?: never;
+            header: {
+                /** @description Should contain oauth token representing the following 2 schemes: 1. Platform self authenticating (client_credentials). 2. Platform authenticating on behalf of end user (authorization_code). */
+                Authorization?: components["parameters"]["authorization"];
+                /** @description Authenticates the platform with a reusable api key allocated to the platform by the business. */
+                "X-API-Key"?: components["parameters"]["x_api_key"];
+                /** @description RFC 9421 HTTP Message Signature. Required when using HTTP Message Signatures for authentication. Format: `sig1=:<base64-signature>:`. */
+                Signature?: components["parameters"]["signature"];
+                /** @description RFC 9421 Signature-Input header. Required when using HTTP Message Signatures for authentication. Format: `sig1=("@method" "@path" ...);created=<timestamp>;keyid="<key-id>"`. */
+                "Signature-Input"?: components["parameters"]["signature_input"];
+                /** @description Body digest per RFC 9530. Required for requests/responses with a body. Format: `sha-256=:<base64-digest>:`. */
+                "Content-Digest"?: components["parameters"]["content_digest"];
+                /** @description For tracing the requests across network layers and components. */
+                "Request-Id": components["parameters"]["request_id"];
+                /** @description Identifies the user agent string making the call. */
+                "User-Agent"?: components["parameters"]["user_agent"];
+                /** @description Identifies the UCP agent making the call. All requests MUST include the UCP-Agent header containing the signer's profile URI using RFC 8941 Dictionary syntax. The URL MUST point to /.well-known/ucp. Format: profile="https://example.com/.well-known/ucp". */
+                "UCP-Agent": components["parameters"]["ucp_agent"];
+                /** @description Representation Metadata. Tells the receiver what the data in the message body actually is. */
+                "Content-Type"?: components["parameters"]["content_type"];
+                /** @description Content Negotiation. The client tells the server what data formats it is capable of understanding. */
+                Accept?: components["parameters"]["accept"];
+                /** @description Localization. Tells the receiver the user's preferred natural languages, often with "weights" or priorities. */
+                "Accept-Language"?: components["parameters"]["accept_language"];
+                /** @description Compression. The client tells the server which content-codings it supports, usually for compression. */
+                "Accept-Encoding"?: components["parameters"]["accept_encoding"];
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["get_product_request"];
+            };
+        };
+        responses: {
+            /** @description Product detail */
+            200: {
+                headers: {
+                    Signature: components["headers"]["signature"];
+                    "Signature-Input": components["headers"]["signature_input"];
+                    "Content-Digest": components["headers"]["content_digest"];
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["catalog_get_product_response"];
+                };
+            };
+        };
+    };
+    order_event_webhook: {
+        parameters: {
+            query?: never;
+            header: {
+                /** @description RFC 9421 HTTP Message Signature. Required when using HTTP Message Signatures for authentication. Format: `sig1=:<base64-signature>:`. */
+                Signature?: components["parameters"]["signature"];
+                /** @description RFC 9421 Signature-Input header. Required when using HTTP Message Signatures for authentication. Format: `sig1=("@method" "@path" ...);created=<timestamp>;keyid="<key-id>"`. */
+                "Signature-Input"?: components["parameters"]["signature_input"];
+                /** @description Body digest per RFC 9530. Required for requests/responses with a body. Format: `sha-256=:<base64-digest>:`. */
+                "Content-Digest"?: components["parameters"]["content_digest"];
+                /** @description Identifies the UCP agent making the call. All requests MUST include the UCP-Agent header containing the signer's profile URI using RFC 8941 Dictionary syntax. The URL MUST point to /.well-known/ucp. Format: profile="https://example.com/.well-known/ucp". */
+                "UCP-Agent": components["parameters"]["ucp_agent"];
+                /** @description Authenticates the platform with a reusable api key allocated to the platform by the business. */
+                "X-API-Key"?: components["parameters"]["x_api_key"];
+                /** @description Webhook event occurrence unix timestamp (seconds since epoch). */
+                "Webhook-Timestamp": components["parameters"]["webhook_timestamp"];
+                /** @description The unique identifier of a webhook event. */
+                "Webhook-Id": components["parameters"]["webhook_id"];
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["order"];
+            };
+        };
+        responses: {
+            /** @description Event received and acknowledged */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        ucp: components["schemas"]["ucp"];
+                    };
+                };
+            };
+        };
+    };
+}