@coveo/quantic 3.10.0 → 3.11.0

package/force-app/main/default/staticresources/coveoheadless/definitions/app/commerce-ssr-engine/types/build.d.ts

@@ -1,17 +1,13 @@
+import { Controller } from '../../../controllers/controller/headless-controller.js';
 import type { ControllersMap, ControllersPropsMap, EngineDefinitionBuildResult, OptionsExtender, OptionsTuple } from '../../ssr-engine/types/common.js';
 import { SSRCommerceEngine } from '../factories/build-factory.js';
-import { EngineDefinitionControllersPropsOption, SolutionType } from './common.js';
+import { ControllerDefinitionsMap, EngineDefinitionControllersPropsOption, SolutionType } from './common.js';
 export interface BuildOptions<TEngineOptions> {
     extend?: OptionsExtender<TEngineOptions>;
 }
-export type Build<TEngineOptions, TControllersMap extends ControllersMap, TControllersProps extends ControllersPropsMap, TSolutionType extends SolutionType> = TSolutionType extends SolutionType.recommendation ? {
+export type Build<TEngineOptions, TControllersMap extends ControllersMap, TControllersProps extends ControllersPropsMap, TControllersDefinitionsMap extends ControllerDefinitionsMap<Controller>, TSolutionType extends SolutionType> = {
     /**
      * Initializes an engine and controllers from the definition.
      */
-    (controllers: (keyof TControllersMap)[]): Promise<EngineDefinitionBuildResult<SSRCommerceEngine, TControllersMap>>;
-} : {
-    /**
-     * Initializes an engine and controllers from the definition.
-     */
-    (...params: OptionsTuple<BuildOptions<TEngineOptions> & EngineDefinitionControllersPropsOption<TControllersProps>>): Promise<EngineDefinitionBuildResult<SSRCommerceEngine, TControllersMap>>;
+    (...params: OptionsTuple<BuildOptions<TEngineOptions> & EngineDefinitionControllersPropsOption<TControllersDefinitionsMap, TControllersProps, TSolutionType>>): Promise<EngineDefinitionBuildResult<SSRCommerceEngine, TControllersMap>>;
 };

package/force-app/main/default/staticresources/coveoheadless/definitions/app/commerce-ssr-engine/types/common.d.ts

@@ -1,15 +1,25 @@
 import { UnknownAction } from '@reduxjs/toolkit';
 import type { Controller } from '../../../controllers/controller/headless-controller.js';
 import type { InvalidControllerDefinition } from '../../../utils/errors.js';
-import type { HasKey, InferControllerStaticStateMapFromControllers, InferControllerStaticStateFromController, InferControllerPropsMapFromDefinitions, ControllerStaticStateMap, EngineDefinitionBuildResult, EngineDefinitionControllersPropsOption, HydratedState, OptionsTuple } from '../../ssr-engine/types/common.js';
+import type { HasKey, InferControllerStaticStateMapFromControllers, InferControllerStaticStateFromController, ControllerStaticStateMap, EngineDefinitionBuildResult, HydratedState, OptionsTuple, ControllersPropsMap, HasKeys, HasRequiredKeys, HasOptionalKeys } from '../../ssr-engine/types/common.js';
 import { SSRCommerceEngine } from '../factories/build-factory.js';
-export type { EngineDefinitionBuildResult, EngineDefinitionControllersPropsOption, HydratedState, OptionsTuple, InferControllerStaticStateFromController, InferControllerStaticStateMapFromControllers, InferControllerPropsMapFromDefinitions, };
+export type { EngineDefinitionBuildResult, HydratedState, OptionsTuple, InferControllerStaticStateFromController, InferControllerStaticStateMapFromControllers, };
 export declare enum SolutionType {
     search = "search",
     listing = "listing",
     standalone = "standalone",
     recommendation = "recommendation"
 }
+export declare const recommendationInternalOptionKey: unique symbol;
+export type RecommendationControllerSettings = {
+    /**
+     * Toggle to enable or disable the recommendation controller.
+     * When set to `true`, the controller will perform a recommendation request server-side.
+     *
+     * @default false
+     */
+    enabled?: boolean;
+};
 export interface ControllerDefinitionWithoutProps<TController extends Controller> {
     /**
      * Creates an instance of the given controller.
@@ -39,7 +49,10 @@ export type ControllerDefinition<TController extends Controller> = ControllerDef
 export interface ControllerDefinitionsMap<TController extends Controller> {
     [customName: string]: ControllerDefinition<TController>;
 }
-export type InferControllerPropsFromDefinition<TController extends ControllerDefinition<Controller>> = TController extends ControllerDefinitionWithProps<Controller, infer Props> ? Props : TController extends ControllerDefinitionWithoutProps<Controller> ? {} : unknown;
+export type InferControllerPropsFromDefinition<TController extends ControllerDefinition<Controller>> = TController extends ControllerDefinitionWithProps<Controller, infer Props> ? HasKey<TController, typeof recommendationInternalOptionKey> extends never ? Props : Props & RecommendationControllerSettings : TController extends ControllerDefinitionWithoutProps<Controller> ? HasKey<TController, typeof recommendationInternalOptionKey> extends never ? {} : RecommendationControllerSettings : unknown;
+export type InferControllerPropsMapFromDefinitions<TControllers extends ControllerDefinitionsMap<Controller>> = {
+    [K in keyof TControllers as HasKeys<InferControllerPropsFromDefinition<TControllers[K]>> extends false ? never : K]: InferControllerPropsFromDefinition<TControllers[K]>;
+};
 export type InferControllerFromDefinition<TDefinition extends ControllerDefinition<Controller>> = TDefinition extends ControllerDefinition<infer TController> ? TController : never;
 export type InferControllersMapFromDefinition<TControllers extends ControllerDefinitionsMap<Controller>, TSolutionType extends SolutionType> = {
     [K in keyof TControllers as HasKey<TControllers[K], TSolutionType> extends never ? never : K]: InferControllerFromDefinition<TControllers[K]>;
@@ -47,6 +60,123 @@ export type InferControllersMapFromDefinition<TControllers extends ControllerDef
 export type InferControllerStaticStateMapFromDefinitionsWithSolutionType<TControllers extends ControllerDefinitionsMap<Controller>, TSolutionType extends SolutionType> = {
     [K in keyof TControllers as HasKey<TControllers[K], TSolutionType> extends never ? never : K]: InferControllerStaticStateFromController<InferControllerFromDefinition<TControllers[K]>>;
 };
+/**
+ * This type defines the required and optional controller props for the engine definition.
+ */
+export type EngineDefinitionControllersPropsOption<TControllers extends ControllerDefinitionsMap<Controller>, TControllersPropsMap extends ControllersPropsMap, TSolutionType extends SolutionType> = OptionalEngineDefinitionControllersPropsOption<TControllers, TControllersPropsMap, TSolutionType> & RequiredEngineDefinitionControllersPropsOption<TControllers, TControllersPropsMap, TSolutionType>;
+/**
+ * Represents an optional engine definition for controller properties.
+ *
+ * This type is used to define a map of optional controller properties based on the provided
+ * controller definitions, controller properties map, and solution type.
+ *
+ * @template TControllers - A map of controller definitions.
+ * @template TControllersPropsMap - A map of controller properties.
+ * @template TSolutionType - The type of solution.
+ *
+ * The type iterates over the controller keys (defined in the engine definition) and includes only those keys where:
+ * 1. The controller can be used for a specific solution type (HasKey<TControllers[K], TSolutionType> is not 'never').
+ * 2. The controller properties have optional options (HasOptionalKeys<ConditionalControllerProps<...>> is true).
+ *
+ * @example
+ * Given the following controller definitions:
+ * ```
+ * const {recommendationEngineDefinition} = defineCommerceEngine({
+ *  controllers: {
+ *    popularViewed: defineRecommendations({
+ *      options: {slotId: 'slot-id'}
+ *    })
+ *  }
+ * });
+ * ```
+ *
+ * The following code will not throw an error since the 'popularViewed' controller props are optional
+ * ```
+ * recommendationEngineDefinition.fetchStaticState({
+ *  controllers: {
+ *    popularViewed: {enabled: true, productId: 'some-product-id'} // This is optional
+ *  }
+ * })
+ * ```
+ *
+ * The following code (with no arguments) is also valid because the 'popularViewed' controller props are optional, and there are no other required controller props in the engine definition.
+ * ```
+ * recommendationEngineDefinition.fetchStaticState()
+ * ```
+ */
+export type OptionalEngineDefinitionControllersPropsOption<TControllers extends ControllerDefinitionsMap<Controller>, TControllersPropsMap extends ControllersPropsMap, TSolutionType extends SolutionType> = {
+    [K in keyof TControllers as HasKey<TControllers[K], TSolutionType> extends never ? never : HasOptionalKeys<ConditionalControllerProps<TControllers, TControllersPropsMap, TSolutionType, K>> extends false ? never : 'controllers']?: ConditionalControllerProps<TControllers, TControllersPropsMap, TSolutionType, K>;
+};
+/**
+ * Represents a type that defines the required controller properties for engine definition controllers.
+ *
+ * @template TControllers - A map of controller definitions.
+ * @template TControllersPropsMap - A map of controller properties.
+ * @template TSolutionType - The type of solution being used.
+ *
+ * The type iterates over the controller keys (defined in the engine definition) and includes only those keys where:
+ * 1. The controller can be used for a specific solution type (HasKey<TControllers[K], TSolutionType> is not 'never').
+ * 2. The controller properties have required options (HasRequiredKeys<ConditionalControllerProps<...>> is true).
+ *
+ * The resulting type maps the valid keys to their corresponding conditional controller properties.
+ *
+ * @example
+ * Given the following controller definitions:
+ * ```
+ * const {standaloneEngineDefinition} = defineCommerceEngine({
+ *  controllers: {cart: defineCart()},
+ * });
+ * ```
+ *
+ * The following code will not throw an error since the 'cart' controller props are required for the standalone engine definition:
+ * ```
+ * standaloneEngineDefinition.fetchStaticState({
+ *   controllers: {
+ *     cart: {initialState: {items: []}},
+ *   },
+ * })
+ * ```
+ *
+ */
+export type RequiredEngineDefinitionControllersPropsOption<TControllers extends ControllerDefinitionsMap<Controller>, TControllersPropsMap extends ControllersPropsMap, TSolutionType extends SolutionType> = {
+    [K in keyof TControllers as HasKey<TControllers[K], TSolutionType> extends never ? never : HasRequiredKeys<ConditionalControllerProps<TControllers, TControllersPropsMap, TSolutionType, K>> extends false ? never : 'controllers']: ConditionalControllerProps<TControllers, TControllersPropsMap, TSolutionType, K>;
+};
+type IsRecommendationController<TController extends ControllerDefinition<Controller>> = HasKey<TController, typeof recommendationInternalOptionKey>;
+/**
+ * This type ensures that recommendation controller props are optional, while other controller props remain required.
+ *
+ * It works by checking if the controller definition includes the `recommendationInternalOptionKey`.
+ *
+ * - If the key is present, the controller props are made optional.
+ * - If the key is absent, the controller props are required.
+ *
+ * Example:
+ *
+ * ```typescript
+ * type ControllerProps = InferControllerPropsFromDefinition<{
+ *   recommendation: defineRecommendation({}),
+ *   cart: defineCart(),
+ * }>;
+ *
+ * // In this example:
+ * // - The `recommendation` controller props are optional.
+ * // - The `cart` controller props are required.
+ *
+ * const props: ControllerProps = {
+ *   cart: {initialState: {items: []}},
+ *   // recommendation props can be omitted
+ * };
+ * ```
+ */
+type RecommendationControllerProps<TControllers extends ControllerDefinitionsMap<Controller>, TControllersPropsMap extends ControllersPropsMap, K extends keyof TControllers> = {
+    [I in keyof TControllersPropsMap as I extends K ? IsRecommendationController<TControllers[I]> extends never ? never : I : never]?: TControllersPropsMap[I];
+} & {
+    [I in keyof TControllersPropsMap as I extends K ? IsRecommendationController<TControllers[I]> extends never ? I : never : never]: TControllersPropsMap[I];
+};
+type DefaultControllerProps<TControllers extends ControllerDefinitionsMap<Controller>, TControllersPropsMap extends ControllersPropsMap, K extends keyof TControllers> = {
+    [I in keyof TControllersPropsMap as I extends K ? I : never]: TControllersPropsMap[I];
+};
+type ConditionalControllerProps<TControllers extends ControllerDefinitionsMap<Controller>, TControllersPropsMap extends ControllersPropsMap, TSolutionType extends SolutionType, K extends keyof TControllers> = TSolutionType extends SolutionType.recommendation ? RecommendationControllerProps<TControllers, TControllersPropsMap, K> : DefaultControllerProps<TControllers, TControllersPropsMap, K>;
 export interface ControllerDefinitionOption {
     /**
      * Whether the controller will be used in a product listing context.
@@ -59,6 +189,20 @@ export interface ControllerDefinitionOption {
      */
     search?: boolean;
 }
+interface NonRecommendationController {
+    /**
+     * @internal
+     */
+    [SolutionType.search]: true;
+    /**
+     * @internal
+     */
+    [SolutionType.listing]: true;
+    /**
+     * @internal
+     */
+    [SolutionType.standalone]: true;
+}
 interface UniversalController {
     /**
      * @internal
@@ -72,6 +216,10 @@ interface UniversalController {
      * @internal
      */
     [SolutionType.standalone]: true;
+    /**
+     * @internal
+     */
+    [SolutionType.recommendation]: true;
 }
 interface SearchOnlyController {
     /**
@@ -101,14 +249,27 @@ interface SearchAndListingController {
      */
     [SolutionType.listing]: true;
 }
+interface ListingAndStandaloneController {
+    /**
+     * @internal
+     */
+    [SolutionType.listing]: true;
+    /**
+     * @internal
+     */
+    [SolutionType.standalone]: true;
+}
 export type SearchOnlyControllerDefinitionWithoutProps<TController extends Controller> = ControllerDefinitionWithoutProps<TController> & SearchOnlyController;
 export type SearchOnlyControllerDefinitionWithProps<TController extends Controller, TProps> = ControllerDefinitionWithProps<TController, TProps> & SearchOnlyController;
+export type ListingAndStandaloneControllerWithoutProps<TController extends Controller> = ControllerDefinitionWithoutProps<TController> & ListingAndStandaloneController;
 export type ListingOnlyControllerDefinitionWithoutProps<TController extends Controller> = ControllerDefinitionWithoutProps<TController> & ListingOnlyController;
 export type ListingOnlyControllerDefinitionWithProps<TController extends Controller, TProps> = ControllerDefinitionWithProps<TController, TProps> & ListingOnlyController;
 export type RecommendationOnlyControllerDefinitionWithoutProps<TController extends Controller> = ControllerDefinitionWithoutProps<TController> & RecommendationOnlyController;
 export type RecommendationOnlyControllerDefinitionWithProps<TController extends Controller, TProps> = ControllerDefinitionWithProps<TController, TProps> & RecommendationOnlyController;
-export type NonRecommendationControllerDefinitionWithoutProps<TController extends Controller> = ControllerDefinitionWithoutProps<TController> & UniversalController;
-export type NonRecommendationControllerDefinitionWithProps<TController extends Controller, TProps> = ControllerDefinitionWithProps<TController, TProps> & UniversalController;
+export type NonRecommendationControllerDefinitionWithoutProps<TController extends Controller> = ControllerDefinitionWithoutProps<TController> & NonRecommendationController;
+export type NonRecommendationControllerDefinitionWithProps<TController extends Controller, TProps> = ControllerDefinitionWithProps<TController, TProps> & NonRecommendationController;
+export type UniversalControllerDefinitionWithoutProps<TController extends Controller> = ControllerDefinitionWithoutProps<TController> & UniversalController;
+export type UniversalControllerDefinitionWithProps<TController extends Controller, TProps> = ControllerDefinitionWithProps<TController, TProps> & UniversalController;
 export type SearchAndListingControllerDefinitionWithoutProps<TController extends Controller> = ControllerDefinitionWithoutProps<TController> & SearchAndListingController;
 export type SearchAndListingControllerDefinitionWithProps<TController extends Controller, TProps> = ControllerDefinitionWithProps<TController, TProps> & SearchAndListingController;
 export type SubControllerDefinitionWithoutProps<TController extends Controller, TDefinition extends ControllerDefinitionOption | undefined> = TDefinition extends {

package/force-app/main/default/staticresources/coveoheadless/definitions/app/commerce-ssr-engine/types/core-engine.d.ts

@@ -23,15 +23,15 @@ export interface EngineDefinition<TControllers extends ControllerDefinitionsMap<
     /**
      * Fetches the static state on the server side using your engine definition.
      */
-    fetchStaticState: FetchStaticState<InferControllersMapFromDefinition<TControllers, TSolutionType>, UnknownAction, InferControllerStaticStateMapFromDefinitionsWithSolutionType<TControllers, TSolutionType>, InferControllerPropsMapFromDefinitions<TControllers>, TSolutionType>;
+    fetchStaticState: FetchStaticState<InferControllersMapFromDefinition<TControllers, TSolutionType>, UnknownAction, InferControllerStaticStateMapFromDefinitionsWithSolutionType<TControllers, TSolutionType>, InferControllerPropsMapFromDefinitions<TControllers>, TControllers, TSolutionType>;
     /**
      * Fetches the hydrated state on the client side using your engine definition and the static state.
      */
-    hydrateStaticState: HydrateStaticState<InferControllersMapFromDefinition<TControllers, TSolutionType>, UnknownAction, InferControllerPropsMapFromDefinitions<TControllers>, TSolutionType>;
+    hydrateStaticState: HydrateStaticState<InferControllersMapFromDefinition<TControllers, TSolutionType>, UnknownAction, InferControllerPropsMapFromDefinitions<TControllers>, TControllers, TSolutionType>;
     /**
      * Builds an engine and its controllers from an engine definition.
      */
-    build: Build<TEngineOptions, InferControllersMapFromDefinition<TControllers, TSolutionType>, InferControllerPropsMapFromDefinitions<TControllers>, TSolutionType>;
+    build: Build<TEngineOptions, InferControllersMapFromDefinition<TControllers, TSolutionType>, InferControllerPropsMapFromDefinitions<TControllers>, TControllers, TSolutionType>;
     /**
      * Sets the navigator context provider.
      * This provider is essential for retrieving navigation-related data such as referrer, userAgent, location, and clientId, which are crucial for handling both server-side and client-side API requests effectively.

package/force-app/main/default/staticresources/coveoheadless/definitions/app/commerce-ssr-engine/types/fetch-static-state.d.ts

@@ -1,23 +1,15 @@
 import type { UnknownAction } from '@reduxjs/toolkit';
-import { SolutionType } from '../../commerce-ssr-engine/types/common.js';
-import type { EngineDefinitionControllersPropsOption, EngineStaticState } from '../../commerce-ssr-engine/types/common.js';
+import { Controller } from '../../../controllers/controller/headless-controller.js';
+import type { ControllerDefinitionsMap, EngineDefinitionControllersPropsOption, EngineStaticState, SolutionType } from '../../commerce-ssr-engine/types/common.js';
 import type { ControllersMap, ControllersPropsMap, ControllerStaticStateMap, OptionsTuple } from '../../ssr-engine/types/common.js';
 import { FromBuildResult } from './from-build-result.js';
 export type FetchStaticStateOptions = {};
-export type FetchStaticState<TControllers extends ControllersMap, TSearchAction extends UnknownAction, TControllersStaticState extends ControllerStaticStateMap, TControllersProps extends ControllersPropsMap, TSolutionType extends SolutionType> = TSolutionType extends SolutionType.recommendation ? {
+export type FetchStaticState<TControllers extends ControllersMap, TSearchAction extends UnknownAction, TControllersStaticState extends ControllerStaticStateMap, TControllersProps extends ControllersPropsMap, TControllersDefinitionsMap extends ControllerDefinitionsMap<Controller>, TSolutionType extends SolutionType> = {
     /**
      * Executes only the initial search for a given configuration, then returns a resumable snapshot of engine state along with the state of the controllers.
      *
      * Useful for static generation and server-side rendering.
      */
-    (controllers: Array<keyof TControllers>): Promise<EngineStaticState<TSearchAction, TControllersStaticState>>;
-    fromBuildResult: FromBuildResult<TControllers, FetchStaticStateOptions, EngineStaticState<TSearchAction, TControllersStaticState>>;
-} : {
-    /**
-     * Executes only the initial search for a given configuration, then returns a resumable snapshot of engine state along with the state of the controllers.
-     *
-     * Useful for static generation and server-side rendering.
-     */
-    (...params: OptionsTuple<FetchStaticStateOptions & EngineDefinitionControllersPropsOption<TControllersProps>>): Promise<EngineStaticState<TSearchAction, TControllersStaticState>>;
+    (...params: OptionsTuple<FetchStaticStateOptions & EngineDefinitionControllersPropsOption<TControllersDefinitionsMap, TControllersProps, TSolutionType>>): Promise<EngineStaticState<TSearchAction, TControllersStaticState>>;
     fromBuildResult: FromBuildResult<TControllers, FetchStaticStateOptions, EngineStaticState<TSearchAction, TControllersStaticState>>;
 };

package/force-app/main/default/staticresources/coveoheadless/definitions/app/commerce-ssr-engine/types/from-build-result.d.ts

@@ -13,7 +13,7 @@ export interface FromBuildResultOptions<TControllers extends ControllersMap> {
      *
      * This is applicable only if the engine is a recommendation engine.
      */
-    allowedRecommendationKeys?: (keyof TControllers)[];
+    allowedRecommendationKeys?: string[];
 }
 export interface FromBuildResult<TControllers extends ControllersMap, TOptions, TReturn> {
     (options: FromBuildResultOptions<TControllers> & TOptions): Promise<TReturn>;

package/force-app/main/default/staticresources/coveoheadless/definitions/app/commerce-ssr-engine/types/hydrate-static-state.d.ts

@@ -1,25 +1,18 @@
 import type { UnknownAction } from '@reduxjs/toolkit';
+import { Controller } from '../../../controllers/controller/headless-controller.js';
 import type { ControllersMap, ControllersPropsMap, HydratedState, OptionsTuple } from '../../ssr-engine/types/common.js';
 import { SSRCommerceEngine } from '../factories/build-factory.js';
-import { EngineDefinitionControllersPropsOption, SolutionType } from './common.js';
+import { ControllerDefinitionsMap, EngineDefinitionControllersPropsOption, SolutionType } from './common.js';
 import { FromBuildResult } from './from-build-result.js';
 export interface HydrateStaticStateOptions<TSearchAction> {
     searchActions: TSearchAction[];
 }
-export type HydrateStaticState<TControllers extends ControllersMap, TSearchAction extends UnknownAction, TControllersProps extends ControllersPropsMap, TSolutionType extends SolutionType> = TSolutionType extends SolutionType.recommendation ? {
+export type HydrateStaticState<TControllers extends ControllersMap, TSearchAction extends UnknownAction, TControllersProps extends ControllersPropsMap, TControllersDefinitionsMap extends ControllerDefinitionsMap<Controller>, TSolutionType extends SolutionType> = {
     /**
      * Creates a new engine from the snapshot of the engine created in SSR with fetchStaticState.
      *
      * Useful when hydrating a server-side-rendered engine.
      */
-    (...params: OptionsTuple<HydrateStaticStateOptions<TSearchAction>>): Promise<HydratedState<SSRCommerceEngine, TControllers>>;
-    fromBuildResult: FromBuildResult<TControllers, HydrateStaticStateOptions<TSearchAction>, HydratedState<SSRCommerceEngine, TControllers>>;
-} : {
-    /**
-     * Creates a new engine from the snapshot of the engine created in SSR with fetchStaticState.
-     *
-     * Useful when hydrating a server-side-rendered engine.
-     */
-    (...params: OptionsTuple<HydrateStaticStateOptions<TSearchAction> & EngineDefinitionControllersPropsOption<TControllersProps>>): Promise<HydratedState<SSRCommerceEngine, TControllers>>;
+    (...params: OptionsTuple<HydrateStaticStateOptions<TSearchAction> & EngineDefinitionControllersPropsOption<TControllersDefinitionsMap, TControllersProps, TSolutionType>>): Promise<HydratedState<SSRCommerceEngine, TControllers>>;
     fromBuildResult: FromBuildResult<TControllers, HydrateStaticStateOptions<TSearchAction>, HydratedState<SSRCommerceEngine, TControllers>>;
 };

package/force-app/main/default/staticresources/coveoheadless/definitions/app/ssr-engine/types/common.d.ts

@@ -3,6 +3,12 @@ import type { Controller } from '../../../controllers/controller/headless-contro
 import { CoreEngine, CoreEngineNext } from '../../engine.js';
 export type HasKey<T, K extends PropertyKey> = T extends unknown ? K extends keyof T ? T[K] extends never ? never : true : never : never;
 export type HasKeys<TObject> = TObject extends {} ? keyof TObject extends never ? false : true : boolean;
+export type HasRequiredKeys<TObject> = TObject extends {} ? {
+    [K in keyof TObject]-?: {} extends Pick<TObject, K> ? never : K;
+}[keyof TObject] extends never ? false : true : boolean;
+export type HasOptionalKeys<TObject> = TObject extends {} ? {
+    [K in keyof TObject]-?: {} extends Pick<TObject, K> ? K : never;
+}[keyof TObject] extends never ? false : true : boolean;
 export type ExtractRequiredOptions<TOptions> = {
     [TKey in keyof TOptions as Pick<TOptions, TKey> extends Required<Pick<TOptions, TKey>> ? TKey : never]: TOptions[TKey];
 };

package/force-app/main/default/staticresources/coveoheadless/definitions/controllers/commerce/context/cart/headless-cart.ssr.d.ts

@@ -1,11 +1,11 @@
-import { NonRecommendationControllerDefinitionWithProps } from '../../../../app/commerce-ssr-engine/types/common.js';
+import { UniversalControllerDefinitionWithProps } from '../../../../app/commerce-ssr-engine/types/common.js';
 import { Cart, CartInitialState } from './headless-cart.js';
 export type { CartState, CartItem, CartProps } from './headless-cart.js';
 export type { Cart, CartInitialState };
 export interface CartBuildProps {
     initialState: CartInitialState;
 }
-export interface CartDefinition extends NonRecommendationControllerDefinitionWithProps<Cart, CartBuildProps> {
+export interface CartDefinition extends UniversalControllerDefinitionWithProps<Cart, CartBuildProps> {
 }
 /**
  * Defines a `Cart` controller instance.

package/force-app/main/default/staticresources/coveoheadless/definitions/controllers/commerce/context/headless-context.ssr.d.ts

@@ -1,8 +1,8 @@
-import { NonRecommendationControllerDefinitionWithProps } from '../../../app/commerce-ssr-engine/types/common.js';
+import { UniversalControllerDefinitionWithProps } from '../../../app/commerce-ssr-engine/types/common.js';
 import { Context, ContextOptions, View, UserLocation } from './headless-context.js';
 export type { ContextState, Context, ContextProps } from './headless-context.js';
 export type { View, UserLocation, ContextOptions };
-export interface ContextDefinition extends NonRecommendationControllerDefinitionWithProps<Context, ContextOptions> {
+export interface ContextDefinition extends UniversalControllerDefinitionWithProps<Context, ContextOptions> {
 }
 /**
  * Defines a `Context` controller instance.

package/force-app/main/default/staticresources/coveoheadless/definitions/controllers/commerce/core/parameter-manager/headless-core-parameter-manager.d.ts

@@ -9,7 +9,7 @@ export interface ParameterManagerProps<T extends Parameters> {
     /**
      * The initial state that should be applied to the `ParameterManager` sub-controller.
      */
-    initialState: ParameterManagerInitialState<T>;
+    initialState?: ParameterManagerInitialState<T>;
 }
 export interface CoreParameterManagerProps<T extends Parameters> extends ParameterManagerProps<T> {
     /**

package/force-app/main/default/staticresources/coveoheadless/definitions/controllers/commerce/recommendations/headless-recommendations.ssr.d.ts

@@ -1,14 +1,14 @@
-import { RecommendationOnlyControllerDefinitionWithoutProps } from '../../../app/commerce-ssr-engine/types/common.js';
-import { RecommendationsState } from '../recommendations/headless-recommendations.js';
+import { recommendationInternalOptionKey, RecommendationOnlyControllerDefinitionWithProps } from '../../../app/commerce-ssr-engine/types/common.js';
+import { RecommendationsOptions, RecommendationsState } from '../recommendations/headless-recommendations.js';
 import { RecommendationsProps, Recommendations } from './headless-recommendations.js';
 export type { Recommendations, RecommendationsState };
 /**
  * @internal
  * */
 export type RecommendationsDefinitionMeta = {
-    options: {} & RecommendationsProps['options'];
+    [recommendationInternalOptionKey]: {} & RecommendationsProps['options'];
 };
-export interface RecommendationsDefinition extends RecommendationOnlyControllerDefinitionWithoutProps<Recommendations> {
+export interface RecommendationsDefinition extends RecommendationOnlyControllerDefinitionWithProps<Recommendations, Partial<RecommendationsOptions>> {
 }
 /**
  * @internal

package/force-app/main/default/staticresources/coveoheadless/definitions/controllers/commerce/standalone-search-box/headless-standalone-search-box.ssr.d.ts

@@ -1,10 +1,10 @@
-import { NonRecommendationControllerDefinitionWithoutProps } from '../../../app/commerce-ssr-engine/types/common.js';
+import { ListingAndStandaloneControllerWithoutProps } from '../../../app/commerce-ssr-engine/types/common.js';
 import { StandaloneSearchBoxProps } from '../../standalone-search-box/headless-standalone-search-box.js';
 import { StandaloneSearchBox } from './headless-standalone-search-box.js';
 export type { StandaloneSearchBoxOptions } from './headless-standalone-search-box-options.js';
 export type { StandaloneSearchBoxState } from './headless-standalone-search-box.js';
 export type { StandaloneSearchBox, StandaloneSearchBoxProps };
-export interface StandaloneSearchBoxDefinition extends NonRecommendationControllerDefinitionWithoutProps<StandaloneSearchBox> {
+export interface StandaloneSearchBoxDefinition extends ListingAndStandaloneControllerWithoutProps<StandaloneSearchBox> {
 }
 /**
  * Defines the `StandaloneSearchBox` controller for the purpose of server-side rendering.