@coveo/thermidor-schema 1.0.0-beta.2 → 1.0.0-beta.21

package/dist/generated/schemas.js

@@ -1,11 +1,10 @@
 // This file is generated from the canonical JSON Schema documents.
 // Do not edit it directly; run `mise run generate` from the repository root.
 import * as z from 'zod/v4';
-// The kind of action: "followup" triggers a conversational follow-up, "search" triggers a
-// standalone search.
-//
+export const CartUpdateOperationSchema = z.enum(['add', 'remove', 'setQuantity']);
 // The kind of action selected: "followup" or "search".
-export const TypeSchema = z.enum(['followup', 'search']);
+export const SelectActionPayloadTypeSchema = z.enum(['followup', 'search']);
+export const ActionItemTypeSchema = z.enum(['followup', 'search', 'searchOption']);
 // The selection state of a facet value, shared across all commerce facet components.
 //
 // The selection state of this facet value.
@@ -20,52 +19,89 @@ export const ProductSchema = z.strictObject({
     get children() {
         return z.array(ProductSchema).optional();
     },
-    clickUri: z.url().optional(),
+    clickUri: z.string().optional(),
     ec_brand: z.string().optional(),
     ec_category: z.array(z.string()).optional(),
     ec_color: z.string().optional(),
     ec_description: z.string().optional(),
-    ec_images: z.array(z.url()).optional(),
+    ec_images: z.array(z.string()).optional(),
     ec_in_stock: z.boolean().optional(),
     ec_item_group_id: z.string().optional(),
     ec_item_group_name: z.string().optional(),
     ec_name: z.string(),
     ec_price: z.number().optional(),
     ec_promo_price: z.number().optional(),
-    ec_rating: z.union([z.number().min(0).max(5), z.null()]).optional(),
+    ec_rating: z.union([z.number().min(0), z.null()]).optional(),
     ec_shortdesc: z.string().optional(),
-    ec_thumbnails: z.array(z.url()).optional(),
+    ec_thumbnails: z.array(z.string()).optional(),
     permanentid: z.string(),
 });
+export const DataBindingSchema = z.strictObject({
+    path: z.string(),
+});
+export const FollowupActionItemSchema = z.strictObject({
+    text: z.string(),
+    type: z.literal('followup'),
+});
+export const SearchActionItemSchema = z.strictObject({
+    text: z.string(),
+    type: z.literal('search'),
+});
+export const SearchOptionActionItemSchema = z.strictObject({
+    optionId: z.string().min(1),
+    text: z.string(),
+    type: z.literal('searchOption'),
+});
+export const ChildListClassSchema = z.strictObject({
+    componentId: z.string().regex(new RegExp('^[a-z][a-z0-9-]*$')),
+    path: z.string(),
+});
 export const ProductCarouselActionsSchema = z.strictObject({});
 export const ProductCarouselStateSchema = z.strictObject({
     heading: z.string(),
     products: z.array(ProductSchema),
 });
-export const CartItemSchema = z.strictObject({
-    name: z.string(),
-    price: z.number().min(0),
-    productId: z.string(),
+export const PurchaseProductSchema = z.strictObject({
+    name: z.string().optional(),
+    price: z.union([z.number(), z.null()]).optional(),
+    productId: z.string().min(1),
     quantity: z.number().int().min(1),
 });
-export const UpdateItemQuantityPayloadSchema = z.strictObject({
-    item: CartItemSchema,
+export const TransactionSchema = z.strictObject({
+    id: z.string().min(1),
+    revenue: z.number(),
 });
-export const CartStateSchema = z.strictObject({
-    items: z.array(CartItemSchema),
+export const UpdateCartPayloadSchema = z.strictObject({
+    name: z.string().optional(),
+    operation: z.enum(['add', 'remove', 'setQuantity']),
+    price: z.union([z.number(), z.null()]).optional(),
+    productId: z.string().min(1),
+    quantity: z.number().int().min(1),
+});
+export const CartStateSchema = z.strictObject({});
+export const FetchSuggestionsPayloadSchema = z.strictObject({
+    query: z.string(),
+});
+export const QueryCompletionSchema = z.strictObject({
+    expression: z.string(),
+    score: z.number().optional(),
 });
 export const SelectActionPayloadSchema = z.strictObject({
     text: z.string(),
     type: z.enum(['followup', 'search']),
 });
-export const ActionItemSchema = z.strictObject({
-    text: z.string(),
-    type: z.enum(['followup', 'search']),
+export const SelectSearchOptionPayloadSchema = z.strictObject({
+    optionId: z.string().min(1),
 });
+export const ActionItemSchema = z.discriminatedUnion('type', [
+    FollowupActionItemSchema,
+    SearchActionItemSchema,
+    SearchOptionActionItemSchema,
+]);
 export const BundleDisplayActionsSchema = z.strictObject({});
 export const BundleSlotSchema = z.strictObject({
     categoryLabel: z.string(),
-    surfaceRef: z.string(),
+    childId: z.string(),
 });
 export const ComparisonTableActionsSchema = z.strictObject({});
 export const ComparisonAttributeSchema = z.strictObject({
@@ -73,23 +109,43 @@ export const ComparisonAttributeSchema = z.strictObject({
     label: z.string(),
 });
 export const ComparisonProductSchema = z.strictObject({
-    imageUrl: z.url().optional(),
+    imageUrl: z.string().optional(),
     name: z.string(),
     price: z.number().optional(),
     productId: z.string(),
-    rating: z.number().min(0).max(5).optional(),
-    values: z.record(z.string(), z.string()),
+    rating: z.number().min(0).optional(),
+    values: z.record(z.string(), z.string()).optional(),
+});
+export const ProductClickPayloadSchema = z.strictObject({
+    name: z.string().optional(),
+    position: z.number().int().min(0),
+    price: z.union([z.number(), z.null()]).optional(),
+    productId: z.string().min(1),
+});
+export const SelectProductsPayloadSchema = z.strictObject({
+    productIds: z.array(z.string().min(1)),
 });
-export const ProductListActionsSchema = z.strictObject({});
 export const ProductListStateSchema = z.strictObject({
     products: z.array(ProductSchema),
 });
+export const ProductSummaryActionsSchema = z.strictObject({});
+export const ProductSummaryStateSchema = z.strictObject({
+    categoryLabel: z.string(),
+    product: z.union([ProductSchema, z.null()]),
+});
+export const ProductResearchCardActionsSchema = z.strictObject({});
+export const ProductResearchCardStateSchema = z.strictObject({
+    bullets: z.array(z.string().min(1)).min(1),
+    product: ProductSchema,
+    summary: z.string().min(1),
+});
 export const SelectPagePayloadSchema = z.strictObject({
     page: z.number().int().min(0),
 });
-export const SetPageSizePayloadSchema = z.strictObject({
+export const PayloadSchema = z.strictObject({
     pageSize: z.number().int().min(1),
 });
+export const ShowMorePayloadSchema = z.strictObject({});
 export const PaginationStateSchema = z.strictObject({
     page: z.number().int().min(0),
     pageSize: z.number().int().min(1),
@@ -104,38 +160,32 @@ export const SortCriterionSchema = z.strictObject({
     fields: z.array(z.unknown()),
     sortCriteria: z.string(),
 });
-export const SubmitQueryPayloadSchema = z.strictObject({
-    query: z.string(),
-});
-export const SearchBoxStateSchema = z.strictObject({
-    query: z.string(),
-});
 export const ActionSchema = z.strictObject({
     payload: z.unknown(),
 });
 export const SearchPayloadSchema = z.strictObject({
-    query: z.string().min(0).max(1024),
+    query: z.string(),
 });
 export const RegularFacetToggleExcludePayloadSchema = z.strictObject({
-    value: z.string().min(1).max(1024),
+    value: z.string().min(1),
 });
 export const RegularFacetToggleSelectPayloadSchema = z.strictObject({
-    value: z.string().min(1).max(1024),
+    value: z.string().min(1),
 });
 export const RegularFacetToggleSingleExcludePayloadSchema = z.strictObject({
-    value: z.string().min(1).max(1024),
+    value: z.string().min(1),
 });
 export const RegularFacetToggleSingleSelectPayloadSchema = z.strictObject({
-    value: z.string().min(1).max(1024),
+    value: z.string().min(1),
 });
 export const RegularFacetSearchResultSchema = z.strictObject({
-    numberOfResults: z.number().int().min(0).max(999999999),
-    value: z.string().min(1).max(1024),
+    numberOfResults: z.number().int().min(0),
+    value: z.string().min(1),
 });
 export const RegularFacetValueSchema = z.strictObject({
-    numberOfResults: z.number().int().min(0).max(999999999),
+    numberOfResults: z.number().int().min(0),
     state: z.enum(['idle', 'selected', 'excluded']),
-    value: z.string().min(1).max(1024),
+    value: z.string().min(1),
 });
 export const NumericFacetApplyCustomRangePayloadSchema = z.strictObject({
     end: z.number(),
@@ -188,7 +238,7 @@ export const DateFacetValueSchema = z.strictObject({
     state: z.enum(['idle', 'selected']),
 });
 export const CategoryFacetSearchPayloadSchema = z.strictObject({
-    query: z.string().max(256),
+    query: z.string(),
 });
 export const CategoryFacetSelectPathPayloadSchema = z.strictObject({
     path: z.array(z.string()),
@@ -204,45 +254,102 @@ export const CategoryFacetValuesSchema = z.strictObject({
     selected: z.union([CategoryFacetValueSchema, z.null()]),
 });
 export const FacetManagerActionsSchema = z.strictObject({});
-export const FacetManagerStateSchema = z.strictObject({
-    facetIds: z.array(z.string().regex(new RegExp('^[a-z][a-z0-9-]*$'))),
+export const FacetManagerStateSchema = z.strictObject({});
+export const OverrideCorrectionPayloadSchema = z.strictObject({
+    originalQuery: z.string().min(1),
 });
-export const ProductCarouselSchema = z.strictObject({
-    actions: ProductCarouselActionsSchema,
-    componentType: z.literal('product-carousel'),
-    state: ProductCarouselStateSchema,
+export const NumericRangeRestoreSchema = z.strictObject({
+    end: z.number(),
+    endInclusive: z.boolean().optional(),
+    start: z.number(),
 });
-export const SetItemsPayloadSchema = z.strictObject({
-    items: z.array(CartItemSchema),
+export const SubmitQueryPayloadSchema = z.strictObject({
+    query: z.string(),
 });
-export const UpdateItemQuantitySchema = z.strictObject({
-    payload: UpdateItemQuantityPayloadSchema,
+export const CommerceSearchStateSchema = z.strictObject({});
+export const LayoutStackActionsSchema = z.strictObject({});
+export const LayoutStackStateSchema = z.strictObject({});
+export const QuerySummaryActionsSchema = z.strictObject({});
+export const QuerySummaryStateSchema = z.strictObject({
+    firstIndex: z.number().int().min(0),
+    lastIndex: z.number().int().min(0),
+    query: z.string(),
+    totalEntries: z.number().int().min(0),
+});
+export const SetPageSizePayloadSchema = z.strictObject({
+    pageSize: z.number().int().min(1),
+});
+export const PageSizeStateSchema = z.strictObject({
+    pageSize: z.number().int().min(1),
+});
+export const ProductCarouselSchema = z.looseObject({
+    actions: ProductCarouselActionsSchema.optional(),
+    component: z.literal('ProductCarousel'),
+    id: z.string().min(1).regex(new RegExp('^[a-z][a-z0-9-]*$')),
+    state: ProductCarouselStateSchema.optional(),
+});
+export const PurchasePayloadSchema = z.strictObject({
+    products: z.array(PurchaseProductSchema),
+    transaction: TransactionSchema,
+});
+export const UpdateCartSchema = z.strictObject({
+    payload: UpdateCartPayloadSchema,
+});
+export const FetchSuggestionsSchema = z.strictObject({
+    payload: FetchSuggestionsPayloadSchema,
+});
+export const QuerySuggestionsStateSchema = z.strictObject({
+    completions: z.array(QueryCompletionSchema),
+    products: z.array(ProductSchema),
+    query: z.string(),
 });
 export const SelectActionSchema = z.strictObject({
     payload: SelectActionPayloadSchema,
 });
+export const SelectSearchOptionSchema = z.strictObject({
+    payload: SelectSearchOptionPayloadSchema,
+});
 export const NextActionsStateSchema = z.strictObject({
-    actions: z.array(ActionItemSchema),
+    suggestedActions: z.array(ActionItemSchema),
 });
 export const BundleTierSchema = z.strictObject({
     description: z.string(),
     label: z.string(),
     slots: z.array(BundleSlotSchema),
+    total: z.number().min(0),
 });
 export const ComparisonTableStateSchema = z.strictObject({
     attributes: z.array(ComparisonAttributeSchema),
+    heading: z.string(),
     products: z.array(ComparisonProductSchema),
+    summary: z.string(),
+});
+export const ProductClickSchema = z.strictObject({
+    payload: ProductClickPayloadSchema,
 });
-export const ProductListSchema = z.strictObject({
-    actions: ProductListActionsSchema,
-    componentType: z.literal('product-list'),
-    state: ProductListStateSchema,
+export const SelectProductsSchema = z.strictObject({
+    payload: SelectProductsPayloadSchema,
+});
+export const ProductSummarySchema = z.looseObject({
+    actions: ProductSummaryActionsSchema.optional(),
+    component: z.literal('ProductSummary'),
+    id: z.string().min(1).regex(new RegExp('^[a-z][a-z0-9-]*$')),
+    state: ProductSummaryStateSchema.optional(),
+});
+export const ProductResearchCardSchema = z.looseObject({
+    actions: ProductResearchCardActionsSchema.optional(),
+    component: z.literal('ProductResearchCard'),
+    id: z.string().min(1).regex(new RegExp('^[a-z][a-z0-9-]*$')),
+    state: ProductResearchCardStateSchema.optional(),
 });
 export const SelectPageSchema = z.strictObject({
     payload: SelectPagePayloadSchema,
 });
-export const SetPageSizeSchema = z.strictObject({
-    payload: SetPageSizePayloadSchema,
+export const PurpleSetPageSizeSchema = z.strictObject({
+    payload: PayloadSchema,
+});
+export const ShowMoreSchema = z.strictObject({
+    payload: ShowMorePayloadSchema,
 });
 export const SelectSortSchema = z.strictObject({
     payload: SelectSortPayloadSchema,
@@ -251,9 +358,6 @@ export const SortStateSchema = z.strictObject({
     appliedSort: SortCriterionSchema,
     availableSorts: z.array(SortCriterionSchema),
 });
-export const SubmitQuerySchema = z.strictObject({
-    payload: SubmitQueryPayloadSchema,
-});
 export const SearchSchema = z.strictObject({
     payload: SearchPayloadSchema,
 });
@@ -271,8 +375,8 @@ export const RegularFacetToggleSingleSelectSchema = z.strictObject({
 });
 export const RegularFacetSearchSchema = z.strictObject({
     canShowMoreResults: z.boolean(),
-    query: z.string().min(0).max(1024),
-    results: z.array(RegularFacetSearchResultSchema).max(1000),
+    query: z.string(),
+    results: z.array(RegularFacetSearchResultSchema),
 });
 export const NumericFacetApplyCustomRangeSchema = z.strictObject({
     payload: NumericFacetApplyCustomRangePayloadSchema,
@@ -291,7 +395,7 @@ export const NumericFacetStateSchema = z.strictObject({
     domain: NumericFacetDomainSchema.optional(),
     field: z.string(),
     hasActiveValues: z.boolean(),
-    values: z.array(NumericFacetValueSchema).max(500),
+    values: z.array(NumericFacetValueSchema),
 });
 export const DateFacetApplyCustomRangeSchema = z.strictObject({
     payload: DateFacetApplyCustomRangePayloadSchema,
@@ -319,38 +423,72 @@ export const CategoryFacetSelectPathSchema = z.strictObject({
 });
 export const FacetSearchClassSchema = z.strictObject({
     canShowMoreResults: z.boolean(),
-    query: z.string().max(256),
+    query: z.string(),
     results: z.array(CategoryFacetValueSchema),
 });
-export const FacetManagerSchema = z.strictObject({
-    actions: FacetManagerActionsSchema,
-    componentType: z.literal('facet-manager'),
-    state: FacetManagerStateSchema,
+export const FacetManagerSchema = z.looseObject({
+    actions: FacetManagerActionsSchema.optional(),
+    component: z.literal('FacetManager'),
+    id: z.string().min(1).regex(new RegExp('^[a-z][a-z0-9-]*$')),
+    state: FacetManagerStateSchema.optional(),
+});
+export const OverrideCorrectionSchema = z.strictObject({
+    payload: OverrideCorrectionPayloadSchema,
+});
+export const FacetRestoreSchema = z.strictObject({
+    facetId: z.string().min(1),
+    numericRanges: z.array(NumericRangeRestoreSchema).optional(),
+    values: z.array(z.string()).optional(),
+});
+export const SubmitQuerySchema = z.strictObject({
+    payload: SubmitQueryPayloadSchema,
 });
-export const SetItemsSchema = z.strictObject({
-    payload: SetItemsPayloadSchema,
+export const LayoutStackSchema = z.looseObject({
+    actions: LayoutStackActionsSchema.optional(),
+    component: z.literal('LayoutStack'),
+    id: z.string().min(1).regex(new RegExp('^[a-z][a-z0-9-]*$')),
+    state: LayoutStackStateSchema.optional(),
+});
+export const QuerySummarySchema = z.looseObject({
+    actions: QuerySummaryActionsSchema.optional(),
+    component: z.literal('QuerySummary'),
+    id: z.string().min(1).regex(new RegExp('^[a-z][a-z0-9-]*$')),
+    state: QuerySummaryStateSchema.optional(),
+});
+export const FluffySetPageSizeSchema = z.strictObject({
+    payload: SetPageSizePayloadSchema,
+});
+export const PurchaseSchema = z.strictObject({
+    payload: PurchasePayloadSchema,
+});
+export const QuerySuggestionsActionsSchema = z.strictObject({
+    fetchSuggestions: FetchSuggestionsSchema,
 });
 export const NextActionsBarActionsSchema = z.strictObject({
     selectAction: SelectActionSchema,
+    selectSearchOption: SelectSearchOptionSchema,
 });
 export const BundleDisplayStateSchema = z.strictObject({
     tiers: z.array(BundleTierSchema),
 });
-export const ComparisonTableSchema = z.strictObject({
-    actions: ComparisonTableActionsSchema,
-    componentType: z.literal('comparison-table'),
-    state: ComparisonTableStateSchema,
+export const ComparisonTableSchema = z.looseObject({
+    actions: ComparisonTableActionsSchema.optional(),
+    component: z.literal('ComparisonTable'),
+    id: z.string().min(1).regex(new RegExp('^[a-z][a-z0-9-]*$')),
+    state: ComparisonTableStateSchema.optional(),
+});
+export const ProductListActionsSchema = z.strictObject({
+    productClick: ProductClickSchema,
+    selectProducts: SelectProductsSchema,
 });
 export const PaginationActionsSchema = z.strictObject({
     selectPage: SelectPageSchema,
-    setPageSize: SetPageSizeSchema,
+    setPageSize: PurpleSetPageSizeSchema,
+    showMore: ShowMoreSchema,
 });
 export const SortActionsSchema = z.strictObject({
     selectSort: SelectSortSchema,
 });
-export const SearchBoxActionsSchema = z.strictObject({
-    submitQuery: SubmitQuerySchema,
-});
 export const RegularFacetActionsSchema = z.strictObject({
     clearAllActiveValues: ActionSchema,
     clearSearch: ActionSchema,
@@ -366,11 +504,11 @@ export const RegularFacetActionsSchema = z.strictObject({
 export const RegularFacetStateSchema = z.strictObject({
     canShowLessValues: z.boolean(),
     canShowMoreValues: z.boolean(),
-    displayName: z.string().min(1).max(255),
+    displayName: z.string(),
     facetSearch: RegularFacetSearchSchema,
-    field: z.string().min(1).max(255),
+    field: z.string().min(1),
     hasActiveValues: z.boolean(),
-    values: z.array(RegularFacetValueSchema).max(1000),
+    values: z.array(RegularFacetValueSchema),
 });
 export const NumericFacetActionsSchema = z.strictObject({
     applyCustomRange: NumericFacetApplyCustomRangeSchema,
@@ -405,135 +543,562 @@ export const CategoryFacetStateSchema = z.strictObject({
     field: z.string(),
     values: CategoryFacetValuesSchema,
 });
+export const RestoreStatePayloadSchema = z.strictObject({
+    facets: z.array(FacetRestoreSchema).optional(),
+    page: z.number().int().min(0),
+    pageSize: z.number().int().min(1),
+    pinnedProducts: z.array(z.string()).optional(),
+    query: z.string(),
+    sortCriteria: z.string().optional(),
+});
+export const PageSizeActionsSchema = z.strictObject({
+    setPageSize: FluffySetPageSizeSchema,
+});
 export const CartActionsSchema = z.strictObject({
-    setItems: SetItemsSchema,
-    updateItemQuantity: UpdateItemQuantitySchema,
-});
-export const NextActionsBarSchema = z.strictObject({
-    actions: NextActionsBarActionsSchema,
-    componentType: z.literal('next-actions-bar'),
-    state: NextActionsStateSchema,
-});
-export const BundleDisplaySchema = z.strictObject({
-    actions: BundleDisplayActionsSchema,
-    componentType: z.literal('bundle-display'),
-    state: BundleDisplayStateSchema,
-});
-export const PaginationSchema = z.strictObject({
-    actions: PaginationActionsSchema,
-    componentType: z.literal('pagination'),
-    state: PaginationStateSchema,
-});
-export const SortSchema = z.strictObject({
-    actions: SortActionsSchema,
-    componentType: z.literal('sort'),
-    state: SortStateSchema,
-});
-export const SearchBoxSchema = z.strictObject({
-    actions: SearchBoxActionsSchema,
-    componentType: z.literal('search-box'),
-    state: SearchBoxStateSchema,
-});
-export const RegularFacetSchema = z.strictObject({
-    actions: RegularFacetActionsSchema,
-    componentType: z.literal('regular-facet'),
-    state: RegularFacetStateSchema,
-});
-export const NumericFacetSchema = z.strictObject({
-    actions: NumericFacetActionsSchema,
-    componentType: z.literal('numeric-facet'),
-    state: NumericFacetStateSchema,
-});
-export const DateFacetSchema = z.strictObject({
-    actions: DateFacetActionsSchema,
-    componentType: z.literal('date-facet'),
-    state: DateFacetStateSchema,
-});
-export const CategoryFacetSchema = z.strictObject({
-    actions: CategoryFacetActionsSchema,
-    componentType: z.literal('category-facet'),
-    state: CategoryFacetStateSchema,
-});
-export const CartSchema = z.strictObject({
-    actions: CartActionsSchema,
-    componentType: z.literal('cart'),
-    state: CartStateSchema,
-});
-export const ComponentContractsSchema = z.discriminatedUnion('componentType', [
+    purchase: PurchaseSchema,
+    updateCart: UpdateCartSchema,
+});
+export const QuerySuggestionsSchema = z.looseObject({
+    actions: QuerySuggestionsActionsSchema.optional(),
+    component: z.literal('QuerySuggestions'),
+    id: z.string().min(1).regex(new RegExp('^[a-z][a-z0-9-]*$')),
+    state: QuerySuggestionsStateSchema.optional(),
+});
+export const NextActionsBarSchema = z.looseObject({
+    actions: NextActionsBarActionsSchema.optional(),
+    component: z.literal('NextActionsBar'),
+    id: z.string().min(1).regex(new RegExp('^[a-z][a-z0-9-]*$')),
+    state: NextActionsStateSchema.optional(),
+});
+export const BundleDisplaySchema = z.looseObject({
+    actions: BundleDisplayActionsSchema.optional(),
+    component: z.literal('BundleDisplay'),
+    id: z.string().min(1).regex(new RegExp('^[a-z][a-z0-9-]*$')),
+    state: BundleDisplayStateSchema.optional(),
+});
+export const ProductListSchema = z.looseObject({
+    actions: ProductListActionsSchema.optional(),
+    component: z.literal('ProductList'),
+    id: z.string().min(1).regex(new RegExp('^[a-z][a-z0-9-]*$')),
+    state: ProductListStateSchema.optional(),
+});
+export const PaginationSchema = z.looseObject({
+    actions: PaginationActionsSchema.optional(),
+    component: z.literal('Pagination'),
+    id: z.string().min(1).regex(new RegExp('^[a-z][a-z0-9-]*$')),
+    state: PaginationStateSchema.optional(),
+});
+export const SortSchema = z.looseObject({
+    actions: SortActionsSchema.optional(),
+    component: z.literal('Sort'),
+    id: z.string().min(1).regex(new RegExp('^[a-z][a-z0-9-]*$')),
+    state: SortStateSchema.optional(),
+});
+export const RegularFacetSchema = z.looseObject({
+    actions: RegularFacetActionsSchema.optional(),
+    component: z.literal('RegularFacet'),
+    id: z.string().min(1).regex(new RegExp('^[a-z][a-z0-9-]*$')),
+    state: RegularFacetStateSchema.optional(),
+});
+export const NumericFacetSchema = z.looseObject({
+    actions: NumericFacetActionsSchema.optional(),
+    component: z.literal('NumericFacet'),
+    id: z.string().min(1).regex(new RegExp('^[a-z][a-z0-9-]*$')),
+    state: NumericFacetStateSchema.optional(),
+});
+export const DateFacetSchema = z.looseObject({
+    actions: DateFacetActionsSchema.optional(),
+    component: z.literal('DateFacet'),
+    id: z.string().min(1).regex(new RegExp('^[a-z][a-z0-9-]*$')),
+    state: DateFacetStateSchema.optional(),
+});
+export const CategoryFacetSchema = z.looseObject({
+    actions: CategoryFacetActionsSchema.optional(),
+    component: z.literal('CategoryFacet'),
+    id: z.string().min(1).regex(new RegExp('^[a-z][a-z0-9-]*$')),
+    state: CategoryFacetStateSchema.optional(),
+});
+export const RestoreStateSchema = z.strictObject({
+    payload: RestoreStatePayloadSchema,
+});
+export const PageSizeSchema = z.looseObject({
+    actions: PageSizeActionsSchema.optional(),
+    component: z.literal('PageSize'),
+    id: z.string().min(1).regex(new RegExp('^[a-z][a-z0-9-]*$')),
+    state: PageSizeStateSchema.optional(),
+});
+export const CartSchema = z.looseObject({
+    actions: CartActionsSchema.optional(),
+    component: z.literal('Cart'),
+    id: z.string().min(1).regex(new RegExp('^[a-z][a-z0-9-]*$')),
+    state: CartStateSchema.optional(),
+});
+export const CommerceSearchActionsSchema = z.strictObject({
+    overrideCorrection: OverrideCorrectionSchema,
+    restoreState: RestoreStateSchema,
+    submitQuery: SubmitQuerySchema,
+});
+export const CommerceSearchSchema = z.looseObject({
+    actions: CommerceSearchActionsSchema.optional(),
+    component: z.literal('CommerceSearch'),
+    id: z.string().min(1).regex(new RegExp('^[a-z][a-z0-9-]*$')),
+    state: CommerceSearchStateSchema.optional(),
+});
+export const ComponentContractsSchema = z.discriminatedUnion('component', [
     ProductCarouselSchema,
     CartSchema,
+    QuerySuggestionsSchema,
     NextActionsBarSchema,
     BundleDisplaySchema,
     ComparisonTableSchema,
     ProductListSchema,
+    ProductSummarySchema,
+    ProductResearchCardSchema,
     PaginationSchema,
     SortSchema,
-    SearchBoxSchema,
     RegularFacetSchema,
     NumericFacetSchema,
     DateFacetSchema,
     CategoryFacetSchema,
     FacetManagerSchema,
+    CommerceSearchSchema,
+    LayoutStackSchema,
+    QuerySummarySchema,
+    PageSizeSchema,
 ]);
 /**
- * Component props schemas.
- * These props are injected by the A2-UI surface layer (backend) and passed to catalog
- * renderers automatically. Consumers should NOT hardcode these values; they arrive via
- * the createSurface message's components[].props.
+ * A2-UI dynamic-value building blocks (self-contained; no renderer / @a2ui/web_core dependency).
+ * A bindable prop is an A2-UI Dynamic_Value: a union admitting a literal resolved value, an
+ * A2-UI Data_Binding object { path }, or a function-call form. The frozen renderer's binder
+ * classifies a field as resolvable only when its schema is such a union including DataBinding,
+ * so it dereferences the { path } against the data model before the renderer sees it.
+ *
+ * `DataBindingSchema` is projected from the shared definitions/data-binding.schema.json (like
+ * ComponentId / ChildList), so it is not re-declared here; the unions below reference it.
  */
-export const BundleDisplayPropsSchema = z.object({
-    componentId: z.string(),
-    componentType: z.literal('bundle-display'),
+export const FunctionCallSchema = z.object({
+    call: z.string(),
+    args: z.record(z.string(), z.any()),
+    returnType: z
+        .enum(['string', 'number', 'boolean', 'array', 'object', 'any', 'void'])
+        .default('boolean'),
+});
+export const DynamicNumberSchema = z.union([z.number(), DataBindingSchema, FunctionCallSchema]);
+export const DynamicStringSchema = z.union([z.string(), DataBindingSchema, FunctionCallSchema]);
+export const DynamicBooleanSchema = z.union([z.boolean(), DataBindingSchema, FunctionCallSchema]);
+export const DynamicStringListSchema = z.union([
+    z.array(z.string()),
+    DataBindingSchema,
+    FunctionCallSchema,
+]);
+export const DynamicValueSchema = z.union([z.unknown(), DataBindingSchema, FunctionCallSchema]);
+/**
+ * The A2-UI Action schema for an action-typed prop: the standard A2-UI event shape
+ * { event: { name; context } }. Named DynamicAction to stay distinct from the generated base
+ * action-contract ActionSchema and from a component's dispatchable *Actions contract.
+ */
+export const DynamicActionSchema = z.object({
+    event: z.object({
+        name: z.string(),
+        context: z.unknown().optional(),
+    }),
 });
-export const CartPropsSchema = z.object({
-    componentId: z.string(),
-    componentType: z.literal('cart'),
+/**
+ * Per-component props schemas for the renderer catalog (one per component), passed to
+ * `createCatalog` as each component's `{ props }` schema. Each bindable prop is an A2-UI
+ * Dynamic_Value, so the renderer's binder resolves its `{ path }` binding against the A2-UI
+ * data model; composition child-ref props stay static so child ids reach the renderer
+ * untouched. The resolved shape a renderer actually reads is the `XxxProps` type.
+ */
+export const BundleDisplayPropsSchema = z.object({
+    tiers: z.union([BundleDisplayStateSchema.shape['tiers'], DataBindingSchema, FunctionCallSchema]),
 });
+export const CartPropsSchema = z.object({});
 export const CategoryFacetPropsSchema = z.object({
-    componentId: z.string(),
-    componentType: z.literal('category-facet'),
+    field: DynamicStringSchema,
+    displayName: DynamicStringSchema,
+    values: z.union([
+        CategoryFacetStateSchema.shape['values'],
+        DataBindingSchema,
+        FunctionCallSchema,
+    ]),
+    canShowMoreValues: DynamicBooleanSchema,
+    canShowLessValues: DynamicBooleanSchema,
+    facetSearch: z.union([
+        CategoryFacetStateSchema.shape['facetSearch'],
+        DataBindingSchema,
+        FunctionCallSchema,
+    ]),
+});
+export const CommerceSearchPropsSchema = z.object({
+    sidebarChild: z.string().optional(),
+    mainChild: z.string().optional(),
 });
 export const ComparisonTablePropsSchema = z.object({
-    componentId: z.string(),
-    componentType: z.literal('comparison-table'),
+    heading: DynamicStringSchema,
+    summary: DynamicStringSchema,
+    products: z.union([
+        ComparisonTableStateSchema.shape['products'],
+        DataBindingSchema,
+        FunctionCallSchema,
+    ]),
+    attributes: z.union([
+        ComparisonTableStateSchema.shape['attributes'],
+        DataBindingSchema,
+        FunctionCallSchema,
+    ]),
 });
 export const DateFacetPropsSchema = z.object({
-    componentId: z.string(),
-    componentType: z.literal('date-facet'),
+    field: DynamicStringSchema,
+    displayName: DynamicStringSchema,
+    values: z.union([DateFacetStateSchema.shape['values'], DataBindingSchema, FunctionCallSchema]),
+    customRange: z.union([
+        DateFacetStateSchema.shape['customRange'],
+        DataBindingSchema,
+        FunctionCallSchema,
+    ]),
+    hasActiveValues: DynamicBooleanSchema,
+    canShowMoreValues: DynamicBooleanSchema,
+    canShowLessValues: DynamicBooleanSchema,
 });
 export const FacetManagerPropsSchema = z.object({
-    componentId: z.string(),
-    componentType: z.literal('facet-manager'),
+    children: z.array(z.string()).optional(),
+});
+export const LayoutStackPropsSchema = z.object({
+    direction: z.string().optional(),
+    children: z.array(z.string()).optional(),
 });
 export const NextActionsBarPropsSchema = z.object({
-    componentId: z.string(),
-    componentType: z.literal('next-actions-bar'),
+    suggestedActions: z.union([
+        NextActionsStateSchema.shape['suggestedActions'],
+        DataBindingSchema,
+        FunctionCallSchema,
+    ]),
 });
 export const NumericFacetPropsSchema = z.object({
-    componentId: z.string(),
-    componentType: z.literal('numeric-facet'),
+    field: DynamicStringSchema,
+    displayName: DynamicStringSchema,
+    values: z.union([NumericFacetStateSchema.shape['values'], DataBindingSchema, FunctionCallSchema]),
+    customRange: z.union([
+        NumericFacetStateSchema.shape['customRange'],
+        DataBindingSchema,
+        FunctionCallSchema,
+    ]),
+    hasActiveValues: DynamicBooleanSchema,
+    canShowMoreValues: DynamicBooleanSchema,
+    canShowLessValues: DynamicBooleanSchema,
+    domain: z.union([NumericFacetStateSchema.shape['domain'], DataBindingSchema, FunctionCallSchema]),
+});
+export const PageSizePropsSchema = z.object({
+    pageSize: DynamicNumberSchema,
 });
 export const PaginationPropsSchema = z.object({
-    componentId: z.string(),
-    componentType: z.literal('pagination'),
+    page: DynamicNumberSchema,
+    pageSize: DynamicNumberSchema,
+    totalEntries: DynamicNumberSchema,
+    totalPages: DynamicNumberSchema,
 });
 export const ProductCarouselPropsSchema = z.object({
-    componentId: z.string(),
-    componentType: z.literal('product-carousel'),
+    heading: DynamicStringSchema,
+    products: z.union([
+        ProductCarouselStateSchema.shape['products'],
+        DataBindingSchema,
+        FunctionCallSchema,
+    ]),
 });
 export const ProductListPropsSchema = z.object({
-    componentId: z.string(),
-    componentType: z.literal('product-list'),
+    products: z.union([
+        ProductListStateSchema.shape['products'],
+        DataBindingSchema,
+        FunctionCallSchema,
+    ]),
+});
+export const ProductResearchCardPropsSchema = z.object({
+    product: z.union([
+        ProductResearchCardStateSchema.shape['product'],
+        DataBindingSchema,
+        FunctionCallSchema,
+    ]),
+    summary: DynamicStringSchema,
+    bullets: DynamicStringListSchema,
+});
+export const ProductSummaryPropsSchema = z.object({
+    categoryLabel: DynamicStringSchema,
+    product: z.union([
+        ProductSummaryStateSchema.shape['product'],
+        DataBindingSchema,
+        FunctionCallSchema,
+    ]),
+});
+export const QuerySuggestionsPropsSchema = z.object({
+    query: DynamicStringSchema,
+    completions: z.union([
+        QuerySuggestionsStateSchema.shape['completions'],
+        DataBindingSchema,
+        FunctionCallSchema,
+    ]),
+    products: z.union([
+        QuerySuggestionsStateSchema.shape['products'],
+        DataBindingSchema,
+        FunctionCallSchema,
+    ]),
+});
+export const QuerySummaryPropsSchema = z.object({
+    query: DynamicStringSchema,
+    firstIndex: DynamicNumberSchema,
+    lastIndex: DynamicNumberSchema,
+    totalEntries: DynamicNumberSchema,
 });
 export const RegularFacetPropsSchema = z.object({
-    componentId: z.string(),
-    componentType: z.literal('regular-facet'),
-});
-export const SearchBoxPropsSchema = z.object({
-    componentId: z.string(),
-    componentType: z.literal('search-box'),
+    field: DynamicStringSchema,
+    displayName: DynamicStringSchema,
+    values: z.union([RegularFacetStateSchema.shape['values'], DataBindingSchema, FunctionCallSchema]),
+    hasActiveValues: DynamicBooleanSchema,
+    canShowMoreValues: DynamicBooleanSchema,
+    canShowLessValues: DynamicBooleanSchema,
+    facetSearch: z.union([
+        RegularFacetStateSchema.shape['facetSearch'],
+        DataBindingSchema,
+        FunctionCallSchema,
+    ]),
 });
 export const SortPropsSchema = z.object({
-    componentId: z.string(),
-    componentType: z.literal('sort'),
+    appliedSort: z.union([
+        SortStateSchema.shape['appliedSort'],
+        DataBindingSchema,
+        FunctionCallSchema,
+    ]),
+    availableSorts: z.union([
+        SortStateSchema.shape['availableSorts'],
+        DataBindingSchema,
+        FunctionCallSchema,
+    ]),
 });
+/**
+ * Per-component action unions in the standard A2-UI event shape
+ * { event: { name: <literal>; context: <typed payload> } }, one member per declared action.
+ * Derived from each component's *Actions contract (action-map key -> payload), NOT from
+ * quicktype's auto-named payload wrappers. A component with no actions has `type XxxAction =
+ * never`. The wire field is `context`; the internal validation layer calls the same data
+ * `payload` (see design: Action typing).
+ */
+export const BundleDisplayActionSchema = z.never();
+export const CartActionSchema = z.union([
+    z.object({
+        event: z.object({
+            name: z.literal('updateCart'),
+            context: z.strictObject({
+                productId: z.string(),
+                name: z.string().optional(),
+                price: z.unknown().optional(),
+                quantity: z.number().int().min(1),
+                operation: z.enum(['add', 'remove', 'setQuantity']),
+            }),
+        }),
+    }),
+    z.object({
+        event: z.object({
+            name: z.literal('purchase'),
+            context: z.strictObject({ products: z.array(z.unknown()), transaction: z.unknown() }),
+        }),
+    }),
+]);
+export const CategoryFacetActionSchema = z.union([
+    z.object({
+        event: z.object({
+            name: z.literal('selectPath'),
+            context: z.strictObject({ path: z.array(z.string()) }),
+        }),
+    }),
+    z.object({ event: z.object({ name: z.literal('clearSelectedPath'), context: z.unknown() }) }),
+    z.object({
+        event: z.object({ name: z.literal('search'), context: z.strictObject({ query: z.string() }) }),
+    }),
+    z.object({ event: z.object({ name: z.literal('showMoreSearchResults'), context: z.unknown() }) }),
+    z.object({ event: z.object({ name: z.literal('clearSearch'), context: z.unknown() }) }),
+    z.object({ event: z.object({ name: z.literal('showMoreValues'), context: z.unknown() }) }),
+    z.object({ event: z.object({ name: z.literal('showLessValues'), context: z.unknown() }) }),
+]);
+export const CommerceSearchActionSchema = z.union([
+    z.object({
+        event: z.object({ name: z.literal('submitQuery'), context: z.strictObject({ query: z.string() }) }),
+    }),
+    z.object({
+        event: z.object({
+            name: z.literal('restoreState'),
+            context: z.strictObject({
+                query: z.string(),
+                page: z.number().int().min(0),
+                pageSize: z.number().int().min(1),
+                sortCriteria: z.string().optional(),
+                facets: z.array(z.unknown()).optional(),
+                pinnedProducts: z.array(z.string()).optional(),
+            }),
+        }),
+    }),
+    z.object({
+        event: z.object({
+            name: z.literal('overrideCorrection'),
+            context: z.strictObject({ originalQuery: z.string() }),
+        }),
+    }),
+]);
+export const ComparisonTableActionSchema = z.never();
+export const DateFacetActionSchema = z.union([
+    z.object({
+        event: z.object({
+            name: z.literal('toggleSelect'),
+            context: z.strictObject({ start: z.string(), end: z.string() }),
+        }),
+    }),
+    z.object({
+        event: z.object({
+            name: z.literal('toggleSingleSelect'),
+            context: z.strictObject({ start: z.string(), end: z.string() }),
+        }),
+    }),
+    z.object({ event: z.object({ name: z.literal('clearAllActiveValues'), context: z.unknown() }) }),
+    z.object({
+        event: z.object({
+            name: z.literal('applyCustomRange'),
+            context: z.strictObject({ start: z.string(), end: z.string() }),
+        }),
+    }),
+    z.object({ event: z.object({ name: z.literal('showMoreValues'), context: z.unknown() }) }),
+    z.object({ event: z.object({ name: z.literal('showLessValues'), context: z.unknown() }) }),
+]);
+export const FacetManagerActionSchema = z.never();
+export const LayoutStackActionSchema = z.never();
+export const NextActionsBarActionSchema = z.union([
+    z.object({
+        event: z.object({
+            name: z.literal('selectAction'),
+            context: z.strictObject({ text: z.string(), type: z.enum(['followup', 'search']) }),
+        }),
+    }),
+    z.object({
+        event: z.object({
+            name: z.literal('selectSearchOption'),
+            context: z.strictObject({ optionId: z.string() }),
+        }),
+    }),
+]);
+export const NumericFacetActionSchema = z.union([
+    z.object({
+        event: z.object({
+            name: z.literal('toggleSelect'),
+            context: z.strictObject({ start: z.number(), end: z.number() }),
+        }),
+    }),
+    z.object({
+        event: z.object({
+            name: z.literal('toggleSingleSelect'),
+            context: z.strictObject({ start: z.number(), end: z.number() }),
+        }),
+    }),
+    z.object({ event: z.object({ name: z.literal('clearAllActiveValues'), context: z.unknown() }) }),
+    z.object({
+        event: z.object({
+            name: z.literal('applyCustomRange'),
+            context: z.strictObject({ start: z.number(), end: z.number() }),
+        }),
+    }),
+    z.object({ event: z.object({ name: z.literal('showMoreValues'), context: z.unknown() }) }),
+    z.object({ event: z.object({ name: z.literal('showLessValues'), context: z.unknown() }) }),
+]);
+export const PageSizeActionSchema = z.union([
+    z.object({
+        event: z.object({
+            name: z.literal('setPageSize'),
+            context: z.strictObject({ pageSize: z.number().int().min(1) }),
+        }),
+    }),
+]);
+export const PaginationActionSchema = z.union([
+    z.object({
+        event: z.object({
+            name: z.literal('selectPage'),
+            context: z.strictObject({ page: z.number().int().min(0) }),
+        }),
+    }),
+    z.object({
+        event: z.object({
+            name: z.literal('setPageSize'),
+            context: z.strictObject({ pageSize: z.number().int().min(1) }),
+        }),
+    }),
+    z.object({ event: z.object({ name: z.literal('showMore'), context: z.strictObject({}) }) }),
+]);
+export const ProductCarouselActionSchema = z.never();
+export const ProductListActionSchema = z.union([
+    z.object({
+        event: z.object({
+            name: z.literal('selectProducts'),
+            context: z.strictObject({ productIds: z.array(z.string()) }),
+        }),
+    }),
+    z.object({
+        event: z.object({
+            name: z.literal('productClick'),
+            context: z.strictObject({
+                productId: z.string(),
+                name: z.string().optional(),
+                price: z.unknown().optional(),
+                position: z.number().int().min(0),
+            }),
+        }),
+    }),
+]);
+export const ProductResearchCardActionSchema = z.never();
+export const ProductSummaryActionSchema = z.never();
+export const QuerySuggestionsActionSchema = z.union([
+    z.object({
+        event: z.object({
+            name: z.literal('fetchSuggestions'),
+            context: z.strictObject({ query: z.string() }),
+        }),
+    }),
+]);
+export const QuerySummaryActionSchema = z.never();
+export const RegularFacetActionSchema = z.union([
+    z.object({
+        event: z.object({
+            name: z.literal('toggleSelect'),
+            context: z.strictObject({ value: z.string() }),
+        }),
+    }),
+    z.object({
+        event: z.object({
+            name: z.literal('toggleExclude'),
+            context: z.strictObject({ value: z.string() }),
+        }),
+    }),
+    z.object({
+        event: z.object({
+            name: z.literal('toggleSingleSelect'),
+            context: z.strictObject({ value: z.string() }),
+        }),
+    }),
+    z.object({
+        event: z.object({
+            name: z.literal('toggleSingleExclude'),
+            context: z.strictObject({ value: z.string() }),
+        }),
+    }),
+    z.object({ event: z.object({ name: z.literal('clearAllActiveValues'), context: z.unknown() }) }),
+    z.object({
+        event: z.object({ name: z.literal('search'), context: z.strictObject({ query: z.string() }) }),
+    }),
+    z.object({ event: z.object({ name: z.literal('showMoreSearchResults'), context: z.unknown() }) }),
+    z.object({ event: z.object({ name: z.literal('clearSearch'), context: z.unknown() }) }),
+    z.object({ event: z.object({ name: z.literal('showMoreValues'), context: z.unknown() }) }),
+    z.object({ event: z.object({ name: z.literal('showLessValues'), context: z.unknown() }) }),
+]);
+export const SortActionSchema = z.union([
+    z.object({
+        event: z.object({
+            name: z.literal('selectSort'),
+            context: z.strictObject({ sortCriteria: z.string(), fields: z.array(z.unknown()) }),
+        }),
+    }),
+]);