@coveo/thermidor-schema 1.0.0-beta.4 → 1.0.0-beta.41

package/dist/generated/zod3/schemas.js

@@ -0,0 +1,1282 @@
+// This file is generated from the canonical JSON Schema documents.
+// Do not edit it directly; run `mise run generate` from the repository root.
+// The Zod 3 dialect of this file. Generated from the same canonical JSON Schema
+// documents as ../schemas.ts; see ../../zod3-compat.ts.
+import * as z from '../../zod3-compat.js';
+export const CartUpdateOperationSchema = z.enum(['add', 'remove', 'setQuantity']);
+// The kind of action selected: "followup" or "search".
+export const SelectActionPayloadTypeSchema = z.enum(['followup', 'search']);
+export const ActionItemTypeSchema = z.enum(['followup', 'search', 'searchOption']);
+// The sort direction: ascending or descending.
+export const SortDirectionSchema = z.enum(['asc', 'desc']);
+// The selection state of a facet value, shared across all commerce facet components.
+//
+// The selection state of this facet value.
+export const FacetValueStateSchema = z.enum(['idle', 'selected']);
+export const BreadboxFacetTypeSchema = z.enum([
+    'dateRange',
+    'hierarchical',
+    'numericalRange',
+    'regular',
+]);
+// What replaced the shopper's query: an automatic query correction, or a query trigger.
+export const QueryCorrectionCauseSchema = z.enum(['correction', 'trigger']);
+export const ProductSchema = z.strictObject({
+    additionalFields: z.record(z.string(), z.unknown()),
+    get badgePlacements() {
+        return z.array(BadgePlacementSchema).optional();
+    },
+    get children() {
+        return z.array(ProductSchema).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.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), z.null()]).optional(),
+    ec_shortdesc: z.string().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 ChildListTemplateSchema = z.strictObject({
+    componentId: z.string().regex(new RegExp('^[a-z][a-z0-9-]*$')),
+    path: z.string(),
+});
+export const BreadboxRegularFacetValueSchema = z.strictObject({
+    state: z.literal('selected'),
+    value: z.string().min(1),
+});
+export const BreadboxNumericalRangeFacetValueSchema = z.strictObject({
+    end: z.number(),
+    start: z.number(),
+});
+export const BreadboxDateRangeFacetValueSchema = z.strictObject({
+    end: z.string(),
+    start: z.string(),
+});
+export const BreadboxHierarchicalFacetSchema = z.strictObject({
+    displayName: z.string(),
+    facetId: z.string().regex(new RegExp('^[a-z][a-z0-9-]*$')),
+    field: z.string().min(1),
+    path: z.array(z.string()).min(1),
+    type: z.literal('hierarchical'),
+});
+export const BreadboxDeselectRegularValueSchema = z.strictObject({
+    facetId: z.string().regex(new RegExp('^[a-z][a-z0-9-]*$')),
+    type: z.literal('regular'),
+    value: z.string().min(1),
+});
+export const BreadboxDeselectNumericalRangeSchema = z.strictObject({
+    end: z.number(),
+    facetId: z.string().regex(new RegExp('^[a-z][a-z0-9-]*$')),
+    start: z.number(),
+    type: z.literal('numericalRange'),
+});
+export const BreadboxDeselectDateRangeSchema = z.strictObject({
+    end: z.string(),
+    facetId: z.string().regex(new RegExp('^[a-z][a-z0-9-]*$')),
+    start: z.string(),
+    type: z.literal('dateRange'),
+});
+export const BreadboxDeselectHierarchicalPathSchema = z.strictObject({
+    facetId: z.string().regex(new RegExp('^[a-z][a-z0-9-]*$')),
+    path: z.array(z.string()).min(1),
+    type: z.literal('hierarchical'),
+});
+export const ProductCarouselActionsSchema = z.strictObject({});
+export const ProductCarouselStateSchema = z.strictObject({
+    heading: z.string(),
+    products: z.array(ProductSchema),
+});
+export const BadgeSchema = z.strictObject({
+    backgroundColor: z.string().optional(),
+    iconUrl: z.string().optional(),
+    text: z.string(),
+    textColor: z.string().optional(),
+});
+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 TransactionSchema = z.strictObject({
+    id: z.string().min(1),
+    revenue: z.number(),
+});
+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 SearchBoxActionsSchema = z.strictObject({});
+export const SearchBoxStateSchema = z.strictObject({});
+export const FetchSuggestionsPayloadSchema = z.strictObject({
+    query: z.string(),
+});
+export const QueryCompletionSchema = z.strictObject({
+    expression: z.string(),
+    score: z.number().optional(),
+});
+export const FetchInstantProductsPayloadSchema = z.strictObject({
+    query: z.string(),
+});
+export const InstantProductsStateSchema = z.strictObject({
+    products: z.array(ProductSchema),
+    query: z.string(),
+});
+export const SelectActionPayloadSchema = z.strictObject({
+    text: z.string(),
+    type: z.enum(['followup', 'search']),
+});
+export const SelectSearchOptionPayloadSchema = z.strictObject({
+    optionId: z.string().min(1),
+    text: z.string(),
+});
+export const ActionItemSchema = z.discriminatedUnion('type', [
+    FollowupActionItemSchema,
+    SearchActionItemSchema,
+    SearchOptionActionItemSchema,
+]);
+export const BundleDisplayActionsSchema = z.strictObject({});
+export const BundleSlotSchema = z.strictObject({
+    categoryLabel: z.string(),
+    childId: z.string(),
+});
+export const ProductResearchCardActionsSchema = z.strictObject({});
+export const ProductResearchRelatedDocumentSchema = z.strictObject({
+    clickUri: z.string().optional(),
+    filetype: z.string().optional(),
+    size: z.number().int().min(0).optional(),
+    title: z.string(),
+});
+export const ComparisonTableActionsSchema = z.strictObject({});
+export const ComparisonAttributeSchema = z.strictObject({
+    key: z.string(),
+    label: z.string(),
+});
+export const ComparisonProductSchema = z.strictObject({
+    imageUrl: z.string().optional(),
+    name: z.string(),
+    price: z.number().optional(),
+    productId: z.string(),
+    rating: z.number().min(0).optional(),
+    relatedDocuments: z.array(ProductResearchRelatedDocumentSchema).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 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 SelectPagePayloadSchema = z.strictObject({
+    page: z.number().int().min(0),
+});
+export const ShowMorePayloadSchema = z.strictObject({});
+export const PaginationStateSchema = z.strictObject({
+    page: z.number().int().min(0),
+    pageSize: z.number().int().min(1),
+    totalEntries: z.number().int().min(0),
+    totalPages: z.number().int().min(0),
+});
+export const SortFieldSchema = z.strictObject({
+    direction: z.enum(['asc', 'desc']),
+    displayName: z.string().optional(),
+    field: z.string().min(1),
+});
+export const SortCriterionSchema = z.strictObject({
+    fields: z.array(SortFieldSchema),
+    sortCriteria: z.string(),
+});
+export const ActionSchema = z.strictObject({
+    payload: z.unknown(),
+});
+export const RegularFacetSearchPayloadSchema = z.strictObject({
+    query: z.string(),
+});
+export const RegularFacetToggleSelectPayloadSchema = z.strictObject({
+    value: z.string().min(1),
+});
+export const RegularFacetToggleSingleSelectPayloadSchema = z.strictObject({
+    value: z.string().min(1),
+});
+export const RegularFacetSearchResultSchema = z.strictObject({
+    numberOfResults: z.number().int().min(0),
+    value: z.string().min(1),
+});
+export const RegularFacetValueSchema = z.strictObject({
+    numberOfResults: z.number().int().min(0),
+    state: z.enum(['idle', 'selected']),
+    value: z.string().min(1),
+});
+export const NumericFacetApplyCustomRangePayloadSchema = z.strictObject({
+    end: z.number(),
+    start: z.number(),
+});
+export const NumericFacetToggleSelectPayloadSchema = z.strictObject({
+    end: z.number(),
+    start: z.number(),
+});
+export const NumericFacetToggleSingleSelectPayloadSchema = z.strictObject({
+    end: z.number(),
+    start: z.number(),
+});
+export const NumericFacetCustomRangeSchema = z.strictObject({
+    end: z.number(),
+    numberOfResults: z.number().int().min(0),
+    start: z.number(),
+});
+export const NumericFacetDomainSchema = z.strictObject({
+    max: z.number().optional(),
+    min: z.number().optional(),
+});
+export const NumericFacetValueSchema = z.strictObject({
+    end: z.number(),
+    numberOfResults: z.number().int().min(0),
+    start: z.number(),
+    state: z.enum(['idle', 'selected']),
+});
+export const DateFacetApplyCustomRangePayloadSchema = z.strictObject({
+    end: z.string(),
+    start: z.string(),
+});
+export const DateFacetToggleSelectPayloadSchema = z.strictObject({
+    end: z.string(),
+    start: z.string(),
+});
+export const DateFacetToggleSingleSelectPayloadSchema = z.strictObject({
+    end: z.string(),
+    start: z.string(),
+});
+export const DateFacetCustomRangeSchema = z.strictObject({
+    end: z.string(),
+    numberOfResults: z.number().int().min(0),
+    start: z.string(),
+});
+export const DateFacetValueSchema = z.strictObject({
+    end: z.string(),
+    numberOfResults: z.number().int().min(0),
+    start: z.string(),
+    state: z.enum(['idle', 'selected']),
+});
+export const CategoryFacetSearchPayloadSchema = z.strictObject({
+    query: z.string(),
+});
+export const CategoryFacetSelectPathPayloadSchema = z.strictObject({
+    path: z.array(z.string()),
+});
+export const CategoryFacetValueSchema = z.strictObject({
+    numberOfResults: z.number().int().min(0),
+    path: z.array(z.string()),
+    value: z.string(),
+});
+export const CategoryFacetValuesSchema = z.strictObject({
+    ancestry: z.array(CategoryFacetValueSchema),
+    children: z.array(CategoryFacetValueSchema),
+    selected: z.union([CategoryFacetValueSchema, z.null()]),
+});
+export const FacetManagerActionsSchema = z.strictObject({});
+export const FacetManagerStateSchema = z.strictObject({});
+export const BreadboxDeselectPayloadSchema = z.discriminatedUnion('type', [
+    BreadboxDeselectRegularValueSchema,
+    BreadboxDeselectNumericalRangeSchema,
+    BreadboxDeselectDateRangeSchema,
+    BreadboxDeselectHierarchicalPathSchema,
+]);
+export const BreadboxFacetValueSchema = z.strictObject({
+    state: z.literal('selected').optional(),
+    value: z.string().min(1).optional(),
+    end: z.union([z.number(), z.string()]).optional(),
+    start: z.union([z.number(), z.string()]).optional(),
+});
+export const InitializePayloadSchema = z.strictObject({});
+export const SessionShellStateSchema = z.strictObject({});
+export const NumericRangeRestoreSchema = z.strictObject({
+    end: z.number(),
+    endInclusive: z.boolean().optional(),
+    start: z.number(),
+});
+export const SubmitQueryPayloadSchema = z.strictObject({
+    query: z.string(),
+});
+export const CommerceSearchStateSchema = z.strictObject({});
+export const LayoutStackActionsSchema = z.strictObject({});
+export const LayoutStackStateSchema = z.strictObject({});
+export const QuerySummaryActionsSchema = z.strictObject({
+    overrideCorrection: ActionSchema,
+});
+export const QueryCorrectionSchema = z.strictObject({
+    canOverride: z.boolean(),
+    cause: z.enum(['correction', 'trigger']),
+    originalQuery: z.string().min(1),
+});
+export const SetPageSizePayloadSchema = z.strictObject({
+    pageSize: z.number().int().min(1),
+});
+export const PageSizeStateSchema = z.strictObject({
+    pageSize: z.number().int().min(1),
+});
+export const BreadboxRegularFacetSchema = z.strictObject({
+    displayName: z.string(),
+    facetId: z.string().regex(new RegExp('^[a-z][a-z0-9-]*$')),
+    field: z.string().min(1),
+    type: z.literal('regular'),
+    values: z.array(BreadboxRegularFacetValueSchema).min(1),
+});
+export const BreadboxNumericalRangeFacetSchema = z.strictObject({
+    displayName: z.string(),
+    facetId: z.string().regex(new RegExp('^[a-z][a-z0-9-]*$')),
+    field: z.string().min(1),
+    type: z.literal('numericalRange'),
+    values: z.array(BreadboxNumericalRangeFacetValueSchema).min(1),
+});
+export const BreadboxDateRangeFacetSchema = z.strictObject({
+    displayName: z.string(),
+    facetId: z.string().regex(new RegExp('^[a-z][a-z0-9-]*$')),
+    field: z.string().min(1),
+    type: z.literal('dateRange'),
+    values: z.array(BreadboxDateRangeFacetValueSchema).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 BadgePlacementSchema = z.strictObject({
+    badges: z.array(BadgeSchema),
+    placementId: z.string(),
+});
+export const PurchasePayloadSchema = z.strictObject({
+    products: z.array(PurchaseProductSchema),
+    transaction: TransactionSchema,
+});
+export const UpdateCartSchema = z.strictObject({
+    payload: UpdateCartPayloadSchema,
+});
+export const SearchBoxSchema = z.looseObject({
+    actions: SearchBoxActionsSchema.optional(),
+    component: z.literal('SearchBox'),
+    id: z.string().min(1).regex(new RegExp('^[a-z][a-z0-9-]*$')),
+    state: SearchBoxStateSchema.optional(),
+});
+export const FetchSuggestionsSchema = z.strictObject({
+    payload: FetchSuggestionsPayloadSchema,
+});
+export const QuerySuggestionsStateSchema = z.strictObject({
+    completions: z.array(QueryCompletionSchema),
+    query: z.string(),
+});
+export const FetchInstantProductsSchema = z.strictObject({
+    payload: FetchInstantProductsPayloadSchema,
+});
+export const SelectActionSchema = z.strictObject({
+    payload: SelectActionPayloadSchema,
+});
+export const SelectSearchOptionSchema = z.strictObject({
+    payload: SelectSearchOptionPayloadSchema,
+});
+export const NextActionsStateSchema = z.strictObject({
+    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 ProductResearchCardStateSchema = z.strictObject({
+    bullets: z.array(z.string().min(1)).min(1),
+    product: ProductSchema,
+    relatedDocuments: z.array(ProductResearchRelatedDocumentSchema).optional(),
+    summary: z.string().min(1),
+});
+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 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 SelectPageSchema = z.strictObject({
+    payload: SelectPagePayloadSchema,
+});
+export const ShowMoreSchema = z.strictObject({
+    payload: ShowMorePayloadSchema,
+});
+export const SelectSortPayloadSchema = z.strictObject({
+    fields: z.array(SortFieldSchema),
+    sortCriteria: z.string(),
+});
+export const SortStateSchema = z.strictObject({
+    appliedSort: SortCriterionSchema,
+    availableSorts: z.array(SortCriterionSchema),
+});
+export const RegularFacetSearchSchema = z.strictObject({
+    payload: RegularFacetSearchPayloadSchema,
+});
+export const RegularFacetToggleSelectSchema = z.strictObject({
+    payload: RegularFacetToggleSelectPayloadSchema,
+});
+export const RegularFacetToggleSingleSelectSchema = z.strictObject({
+    payload: RegularFacetToggleSingleSelectPayloadSchema,
+});
+export const RegularFacetSearchStateSchema = z.strictObject({
+    canShowMoreResults: z.boolean(),
+    query: z.string(),
+    results: z.array(RegularFacetSearchResultSchema),
+});
+export const NumericFacetApplyCustomRangeSchema = z.strictObject({
+    payload: NumericFacetApplyCustomRangePayloadSchema,
+});
+export const NumericFacetToggleSelectSchema = z.strictObject({
+    payload: NumericFacetToggleSelectPayloadSchema,
+});
+export const NumericFacetToggleSingleSelectSchema = z.strictObject({
+    payload: NumericFacetToggleSingleSelectPayloadSchema,
+});
+export const NumericFacetStateSchema = z.strictObject({
+    canShowLessValues: z.boolean(),
+    canShowMoreValues: z.boolean(),
+    customRange: z.union([NumericFacetCustomRangeSchema, z.null()]),
+    displayName: z.string(),
+    domain: NumericFacetDomainSchema.optional(),
+    field: z.string(),
+    hasActiveValues: z.boolean(),
+    values: z.array(NumericFacetValueSchema),
+});
+export const DateFacetApplyCustomRangeSchema = z.strictObject({
+    payload: DateFacetApplyCustomRangePayloadSchema,
+});
+export const DateFacetToggleSelectSchema = z.strictObject({
+    payload: DateFacetToggleSelectPayloadSchema,
+});
+export const DateFacetToggleSingleSelectSchema = z.strictObject({
+    payload: DateFacetToggleSingleSelectPayloadSchema,
+});
+export const DateFacetStateSchema = z.strictObject({
+    canShowLessValues: z.boolean(),
+    canShowMoreValues: z.boolean(),
+    customRange: z.union([DateFacetCustomRangeSchema, z.null()]),
+    displayName: z.string(),
+    field: z.string(),
+    hasActiveValues: z.boolean(),
+    values: z.array(DateFacetValueSchema),
+});
+export const CategoryFacetSearchSchema = z.strictObject({
+    payload: CategoryFacetSearchPayloadSchema,
+});
+export const CategoryFacetSelectPathSchema = z.strictObject({
+    payload: CategoryFacetSelectPathPayloadSchema,
+});
+export const CategoryFacetSearchStateSchema = z.strictObject({
+    canShowMoreResults: z.boolean(),
+    query: z.string(),
+    results: z.array(CategoryFacetValueSchema),
+});
+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 BreadboxDeselectSchema = z.strictObject({
+    payload: BreadboxDeselectPayloadSchema,
+});
+export const BreadboxFacetSchema = z.discriminatedUnion('type', [
+    BreadboxRegularFacetSchema,
+    BreadboxNumericalRangeFacetSchema,
+    BreadboxDateRangeFacetSchema,
+    BreadboxHierarchicalFacetSchema,
+]);
+export const InitializeSchema = z.strictObject({
+    payload: InitializePayloadSchema,
+});
+export const FacetRestoreSchema = z.strictObject({
+    facetId: z.string().min(1),
+    numericRanges: z.array(NumericRangeRestoreSchema).optional(),
+    path: z.array(z.string()).optional(),
+    values: z.array(z.string()).optional(),
+});
+export const SubmitQuerySchema = z.strictObject({
+    payload: SubmitQueryPayloadSchema,
+});
+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 QuerySummaryStateSchema = z.strictObject({
+    correction: QueryCorrectionSchema.optional(),
+    firstIndex: z.number().int().min(0),
+    lastIndex: z.number().int().min(0),
+    query: z.string(),
+    totalEntries: z.number().int().min(0),
+});
+export const SetPageSizeSchema = z.strictObject({
+    payload: SetPageSizePayloadSchema,
+});
+export const PurchaseSchema = z.strictObject({
+    payload: PurchasePayloadSchema,
+});
+export const QuerySuggestionsActionsSchema = z.strictObject({
+    fetchSuggestions: FetchSuggestionsSchema,
+});
+export const InstantProductsActionsSchema = z.strictObject({
+    fetchInstantProducts: FetchInstantProductsSchema,
+});
+export const NextActionsBarActionsSchema = z.strictObject({
+    selectAction: SelectActionSchema,
+    selectSearchOption: SelectSearchOptionSchema,
+});
+export const BundleDisplayStateSchema = z.strictObject({
+    heading: z.string().optional(),
+    tiers: z.array(BundleTierSchema),
+});
+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 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,
+    showMore: ShowMoreSchema,
+});
+export const SelectSortSchema = z.strictObject({
+    payload: SelectSortPayloadSchema,
+});
+export const RegularFacetActionsSchema = z.strictObject({
+    clearAllActiveValues: ActionSchema,
+    clearSearch: ActionSchema,
+    search: RegularFacetSearchSchema,
+    showLessValues: ActionSchema,
+    showMoreSearchResults: ActionSchema,
+    showMoreValues: ActionSchema,
+    toggleSelect: RegularFacetToggleSelectSchema,
+    toggleSingleSelect: RegularFacetToggleSingleSelectSchema,
+});
+export const RegularFacetStateSchema = z.strictObject({
+    canShowLessValues: z.boolean(),
+    canShowMoreValues: z.boolean(),
+    displayName: z.string(),
+    facetSearch: RegularFacetSearchStateSchema,
+    field: z.string().min(1),
+    hasActiveValues: z.boolean(),
+    values: z.array(RegularFacetValueSchema),
+});
+export const NumericFacetActionsSchema = z.strictObject({
+    applyCustomRange: NumericFacetApplyCustomRangeSchema,
+    clearAllActiveValues: ActionSchema,
+    showLessValues: ActionSchema,
+    showMoreValues: ActionSchema,
+    toggleSelect: NumericFacetToggleSelectSchema,
+    toggleSingleSelect: NumericFacetToggleSingleSelectSchema,
+});
+export const DateFacetActionsSchema = z.strictObject({
+    applyCustomRange: DateFacetApplyCustomRangeSchema,
+    clearAllActiveValues: ActionSchema,
+    showLessValues: ActionSchema,
+    showMoreValues: ActionSchema,
+    toggleSelect: DateFacetToggleSelectSchema,
+    toggleSingleSelect: DateFacetToggleSingleSelectSchema,
+});
+export const CategoryFacetActionsSchema = z.strictObject({
+    clearSearch: ActionSchema,
+    clearSelectedPath: ActionSchema,
+    search: CategoryFacetSearchSchema,
+    selectPath: CategoryFacetSelectPathSchema,
+    showLessValues: ActionSchema,
+    showMoreSearchResults: ActionSchema,
+    showMoreValues: ActionSchema,
+});
+export const CategoryFacetStateSchema = z.strictObject({
+    canShowLessValues: z.boolean(),
+    canShowMoreValues: z.boolean(),
+    displayName: z.string(),
+    facetSearch: CategoryFacetSearchStateSchema,
+    field: z.string(),
+    values: CategoryFacetValuesSchema,
+});
+export const BreadboxActionsSchema = z.strictObject({
+    clearAll: ActionSchema,
+    deselect: BreadboxDeselectSchema,
+});
+export const BreadboxStateSchema = z.strictObject({
+    facets: z.array(BreadboxFacetSchema),
+});
+export const SessionShellActionsSchema = z.strictObject({
+    initialize: InitializeSchema,
+});
+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 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 PageSizeActionsSchema = z.strictObject({
+    setPageSize: SetPageSizeSchema,
+});
+export const CartActionsSchema = z.strictObject({
+    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 InstantProductsSchema = z.looseObject({
+    actions: InstantProductsActionsSchema.optional(),
+    component: z.literal('InstantProducts'),
+    id: z.string().min(1).regex(new RegExp('^[a-z][a-z0-9-]*$')),
+    state: InstantProductsStateSchema.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 SortActionsSchema = z.strictObject({
+    selectSort: SelectSortSchema,
+});
+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 BreadboxSchema = z.looseObject({
+    actions: BreadboxActionsSchema.optional(),
+    component: z.literal('Breadbox'),
+    id: z.string().min(1).regex(new RegExp('^[a-z][a-z0-9-]*$')),
+    state: BreadboxStateSchema.optional(),
+});
+export const SessionShellSchema = z.looseObject({
+    actions: SessionShellActionsSchema.optional(),
+    component: z.literal('SessionShell'),
+    id: z.string().min(1).regex(new RegExp('^[a-z][a-z0-9-]*$')),
+    state: SessionShellStateSchema.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 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 CommerceSearchActionsSchema = z.strictObject({
+    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,
+    SearchBoxSchema,
+    QuerySuggestionsSchema,
+    InstantProductsSchema,
+    NextActionsBarSchema,
+    BundleDisplaySchema,
+    ProductResearchCardSchema,
+    ComparisonTableSchema,
+    ProductListSchema,
+    ProductSummarySchema,
+    PaginationSchema,
+    SortSchema,
+    RegularFacetSchema,
+    NumericFacetSchema,
+    DateFacetSchema,
+    CategoryFacetSchema,
+    FacetManagerSchema,
+    BreadboxSchema,
+    SessionShellSchema,
+    CommerceSearchSchema,
+    LayoutStackSchema,
+    QuerySummarySchema,
+    PageSizeSchema,
+]);
+/**
+ * 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 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(),
+    }),
+});
+/**
+ * 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 BreadboxPropsSchema = z.object({
+    facets: z.union([BreadboxStateSchema.shape['facets'], DataBindingSchema, FunctionCallSchema]),
+});
+export const BundleDisplayPropsSchema = z.object({
+    heading: DynamicStringSchema.optional(),
+    tiers: z.union([BundleDisplayStateSchema.shape['tiers'], DataBindingSchema, FunctionCallSchema]),
+});
+export const CartPropsSchema = z.object({});
+export const CategoryFacetPropsSchema = z.object({
+    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({
+    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({
+    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({
+    children: z.array(z.string()).optional(),
+});
+export const InstantProductsPropsSchema = z.object({
+    query: DynamicStringSchema,
+    products: z.union([
+        InstantProductsStateSchema.shape['products'],
+        DataBindingSchema,
+        FunctionCallSchema,
+    ]),
+});
+export const LayoutStackPropsSchema = z.object({
+    direction: z.string().optional(),
+    children: z.array(z.string()).optional(),
+});
+export const NextActionsBarPropsSchema = z.object({
+    suggestedActions: z.union([
+        NextActionsStateSchema.shape['suggestedActions'],
+        DataBindingSchema,
+        FunctionCallSchema,
+    ]),
+});
+export const NumericFacetPropsSchema = z.object({
+    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])
+        .optional(),
+});
+export const PageSizePropsSchema = z.object({
+    pageSize: DynamicNumberSchema,
+});
+export const PaginationPropsSchema = z.object({
+    page: DynamicNumberSchema,
+    pageSize: DynamicNumberSchema,
+    totalEntries: DynamicNumberSchema,
+    totalPages: DynamicNumberSchema,
+});
+export const ProductCarouselPropsSchema = z.object({
+    heading: DynamicStringSchema,
+    products: z.union([
+        ProductCarouselStateSchema.shape['products'],
+        DataBindingSchema,
+        FunctionCallSchema,
+    ]),
+});
+export const ProductListPropsSchema = z.object({
+    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,
+    relatedDocuments: z
+        .union([
+        ProductResearchCardStateSchema.shape['relatedDocuments'],
+        DataBindingSchema,
+        FunctionCallSchema,
+    ])
+        .optional(),
+});
+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,
+    ]),
+});
+export const QuerySummaryPropsSchema = z.object({
+    query: DynamicStringSchema,
+    firstIndex: DynamicNumberSchema,
+    lastIndex: DynamicNumberSchema,
+    totalEntries: DynamicNumberSchema,
+    correction: z
+        .union([QuerySummaryStateSchema.shape['correction'], DataBindingSchema, FunctionCallSchema])
+        .optional(),
+});
+export const RegularFacetPropsSchema = z.object({
+    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 SearchBoxPropsSchema = z.object({
+    suggestionsChild: z.string().optional(),
+    instantProductsChild: z.string().optional(),
+});
+export const SessionShellPropsSchema = z.object({
+    children: z.array(z.string()).optional(),
+});
+export const SortPropsSchema = z.object({
+    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 BreadboxActionSchema = z.union([
+    z.object({
+        event: z.object({ name: z.literal('deselect'), context: BreadboxDeselectPayloadSchema }),
+    }),
+    z.object({ event: z.object({ name: z.literal('clearAll'), context: z.unknown() }) }),
+]);
+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(),
+            }),
+        }),
+    }),
+]);
+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 InstantProductsActionSchema = z.union([
+    z.object({
+        event: z.object({
+            name: z.literal('fetchInstantProducts'),
+            context: z.strictObject({ query: z.string() }),
+        }),
+    }),
+]);
+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(), text: 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('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.union([
+    z.object({ event: z.object({ name: z.literal('overrideCorrection'), context: z.unknown() }) }),
+]);
+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('toggleSingleSelect'),
+            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 SearchBoxActionSchema = z.never();
+export const SessionShellActionSchema = z.union([
+    z.object({ event: z.object({ name: z.literal('initialize'), context: z.strictObject({}) }) }),
+]);
+export const SortActionSchema = z.union([
+    z.object({
+        event: z.object({
+            name: z.literal('selectSort'),
+            context: z.strictObject({ sortCriteria: z.string(), fields: z.array(SortFieldSchema) }),
+        }),
+    }),
+]);