@coveo/quantic 3.10.0-pre.faaf12d7a7 → 3.11.0

package/force-app/main/default/staticresources/coveoheadless/definitions/api/commerce/common/request.d.ts

@@ -18,10 +18,10 @@ export declare const buildRequest: (req: CommerceAPIRequest, path: CommerceApiMe
         sort: import("./sort.js").SortOption | undefined;
     };
     url: string;
-    origin: import("../../preprocess-request.js").PlatformClientOrigin;
     accessToken: string;
     method: import("../../platform-client.js").HttpMethods;
     contentType: import("../../platform-client.js").HTTPContentType;
+    origin: import("../../preprocess-request.js").PlatformClientOrigin;
     requestMetadata?: import("../../preprocess-request.js").RequestMetadata | undefined;
 };
 export declare const baseRequest: (req: BaseParam, path: CommerceApiMethod) => Pick<PlatformClientCallOptions, 'accessToken' | 'method' | 'contentType' | 'url' | 'origin' | 'requestMetadata'>;

package/force-app/main/default/staticresources/coveoheadless/definitions/api/commerce/recommendations/recommendations-request.d.ts

@@ -15,9 +15,9 @@ export declare const buildRecommendationsRequest: (req: CommerceRecommendationsR
         perPage: number | undefined;
     };
     url: string;
-    origin: import("../../preprocess-request.js").PlatformClientOrigin;
     accessToken: string;
     method: import("../../platform-client.js").HttpMethods;
     contentType: import("../../platform-client.js").HTTPContentType;
+    origin: import("../../preprocess-request.js").PlatformClientOrigin;
     requestMetadata?: import("../../preprocess-request.js").RequestMetadata | undefined;
 };

package/force-app/main/default/staticresources/coveoheadless/definitions/api/commerce/search/query-suggest/query-suggest-request.d.ts

@@ -12,9 +12,9 @@ export declare const buildQuerySuggestRequest: (req: QuerySuggestRequest) => {
         currency: string;
     };
     url: string;
-    origin: import("../../../preprocess-request.js").PlatformClientOrigin;
     accessToken: string;
     method: import("../../../platform-client.js").HttpMethods;
     contentType: import("../../../platform-client.js").HTTPContentType;
+    origin: import("../../../preprocess-request.js").PlatformClientOrigin;
     requestMetadata?: import("../../../preprocess-request.js").RequestMetadata | undefined;
 };

package/force-app/main/default/staticresources/coveoheadless/definitions/api/knowledge/stream-answer-api.d.ts

@@ -70,7 +70,7 @@ export declare const constructAnswerQueryParams: (state: StateNeededByAnswerAPI,
     } | undefined;
     enableDidYouMean?: boolean | undefined;
     fieldsToInclude?: string[] | undefined;
-    facets?: (import("../../features/facets/facet-set/interfaces/request.js").FacetRequest | import("../../features/facets/category-facet-set/interfaces/request.js").CategoryFacetRequest | import("../../features/facets/range-facets/numeric-facet-set/interfaces/request.js").NumericFacetRequest | import("../../features/facets/range-facets/date-facet-set/interfaces/request.js").DateFacetRequest)[] | undefined;
+    facets?: (import("../../features/facets/facet-set/interfaces/request.js").FacetRequest | import("../../features/facets/category-facet-set/interfaces/request.js").CategoryFacetRequest | import("../../features/facets/range-facets/date-facet-set/interfaces/request.js").DateFacetRequest | import("../../features/facets/range-facets/numeric-facet-set/interfaces/request.js").NumericFacetRequest)[] | undefined;
     pipeline?: string | undefined;
     searchHub?: string | undefined;
     q: string | undefined;

package/force-app/main/default/staticresources/coveoheadless/definitions/api/service/case-assist/get-case-classifications/get-case-classifications-request.d.ts

@@ -8,8 +8,8 @@ export declare const buildGetCaseClassificationsRequest: (req: GetCaseClassifica
         fields: import("../case-assist-params.js").CaseFields;
     };
     url: string;
-    origin: import("../../../preprocess-request.js").PlatformClientOrigin;
     accessToken: string;
     method: import("../../../platform-client.js").HttpMethods;
     contentType: import("../../../platform-client.js").HTTPContentType;
+    origin: import("../../../preprocess-request.js").PlatformClientOrigin;
 };

package/force-app/main/default/staticresources/coveoheadless/definitions/api/service/case-assist/get-document-suggestions/get-document-suggestions-request.d.ts

@@ -9,8 +9,8 @@ export declare const buildGetDocumentSuggestionsRequest: (req: GetDocumentSugges
         context: Record<string, string | string[]> | undefined;
     };
     url: string;
-    origin: import("../../../preprocess-request.js").PlatformClientOrigin;
     accessToken: string;
     method: import("../../../platform-client.js").HttpMethods;
     contentType: import("../../../platform-client.js").HTTPContentType;
+    origin: import("../../../preprocess-request.js").PlatformClientOrigin;
 };

package/force-app/main/default/staticresources/coveoheadless/definitions/api/service/insight/get-interface/get-interface-config-request.d.ts

@@ -4,8 +4,8 @@ export type GetInsightInterfaceConfigRequest = BaseParam & InsightIdParam;
 export declare const buildGetInsightInterfaceConfigRequest: (req: GetInsightInterfaceConfigRequest) => {
     requestParams: {};
     url: string;
-    origin: import("../../../preprocess-request.js").PlatformClientOrigin;
     accessToken: string;
     method: import("../../../platform-client.js").HttpMethods;
     contentType: import("../../../platform-client.js").HTTPContentType;
+    origin: import("../../../preprocess-request.js").PlatformClientOrigin;
 };

package/force-app/main/default/staticresources/coveoheadless/definitions/api/service/insight/query/query-request.d.ts

@@ -9,17 +9,17 @@ interface CaseContextParam {
 export declare const buildInsightQueryRequest: (req: InsightQueryRequest) => {
     requestParams: {};
     url: string;
-    origin: import("../../../preprocess-request.js").PlatformClientOrigin;
     accessToken: string;
     method: import("../../../platform-client.js").HttpMethods;
     contentType: import("../../../platform-client.js").HTTPContentType;
+    origin: import("../../../preprocess-request.js").PlatformClientOrigin;
 };
 export declare const buildInsightQuerySuggestRequest: (req: InsightQuerySuggestRequest) => {
     requestParams: {};
     url: string;
-    origin: import("../../../preprocess-request.js").PlatformClientOrigin;
     accessToken: string;
     method: import("../../../platform-client.js").HttpMethods;
     contentType: import("../../../platform-client.js").HTTPContentType;
+    origin: import("../../../preprocess-request.js").PlatformClientOrigin;
 };
 export {};

package/force-app/main/default/staticresources/coveoheadless/definitions/api/service/insight/user-actions/user-actions-request.d.ts

@@ -11,9 +11,9 @@ export declare const buildInsightUserActionsRequest: (req: InsightUserActionsReq
         objectId: string;
     };
     url: string;
-    origin: import("../../../preprocess-request.js").PlatformClientOrigin;
     accessToken: string;
     method: import("../../../platform-client.js").HttpMethods;
     contentType: import("../../../platform-client.js").HTTPContentType;
+    origin: import("../../../preprocess-request.js").PlatformClientOrigin;
 };
 export {};

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

@@ -1,21 +1,11 @@
 /**
  * Utility functions to be used for Commerce Server Side Rendering.
  */
-import { Action } from '@reduxjs/toolkit';
 import type { Controller } from '../../controllers/controller/headless-controller.js';
+import { CommerceEngineDefinitionOptions } from '../commerce-ssr-engine/factories/build-factory.js';
 import { ControllerDefinitionsMap, SolutionType } from '../commerce-ssr-engine/types/common.js';
-import { EngineDefinition, EngineDefinitionOptions } from '../commerce-ssr-engine/types/core-engine.js';
-import { CommerceEngine, CommerceEngineOptions } from './commerce-engine.js';
-/**
- * The SSR commerce engine.
- */
-export interface SSRCommerceEngine extends CommerceEngine {
-    /**
-     * Waits for the search to be completed and returns a promise that resolves to a `SearchCompletedAction`.
-     */
-    waitForRequestCompletedAction(): Promise<Action>;
-}
-export type CommerceEngineDefinitionOptions<TControllers extends ControllerDefinitionsMap<Controller>> = EngineDefinitionOptions<CommerceEngineOptions, TControllers>;
+import { EngineDefinition } from '../commerce-ssr-engine/types/core-engine.js';
+import { CommerceEngineOptions } from './commerce-engine.js';
 export interface CommerceEngineDefinition<TControllers extends ControllerDefinitionsMap<Controller>, TSolutionType extends SolutionType> extends EngineDefinition<TControllers, CommerceEngineOptions, TSolutionType> {
 }
 /**
@@ -28,4 +18,5 @@ export declare function defineCommerceEngine<TControllerDefinitions extends Cont
     listingEngineDefinition: CommerceEngineDefinition<TControllerDefinitions, SolutionType.listing>;
     searchEngineDefinition: CommerceEngineDefinition<TControllerDefinitions, SolutionType.search>;
     standaloneEngineDefinition: CommerceEngineDefinition<TControllerDefinitions, SolutionType.standalone>;
+    recommendationEngineDefinition: CommerceEngineDefinition<TControllerDefinitions, SolutionType.recommendation>;
 };

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

@@ -1,7 +1,12 @@
+import { UnknownAction } from '@reduxjs/toolkit';
 import { Controller } from '../../controllers/controller/headless-controller.js';
-import { SSRCommerceEngine } from '../commerce-engine/commerce-engine.ssr.js';
-import { InferControllerPropsMapFromDefinitions } from '../ssr-engine/types/common.js';
-import { ControllerDefinitionOption, ControllerDefinitionsMap, InferControllersMapFromDefinition, SolutionType } from './types/common.js';
+import { ControllersMap, InferControllerStaticStateMapFromControllers } from '../ssr-engine/types/common.js';
+import { SSRCommerceEngine } from './factories/build-factory.js';
+import { ControllerDefinitionOption, ControllerDefinitionsMap, EngineStaticState, InferControllerPropsMapFromDefinitions, InferControllersMapFromDefinition, SolutionType } from './types/common.js';
+export declare function createStaticState<TSearchAction extends UnknownAction>({ searchActions, controllers, }: {
+    searchActions: TSearchAction[];
+    controllers: ControllersMap;
+}): EngineStaticState<TSearchAction, InferControllerStaticStateMapFromControllers<ControllersMap>>;
 export declare function buildControllerDefinitions<TControllerDefinitionsMap extends ControllerDefinitionsMap<Controller>, TSolutionType extends SolutionType>({ definitionsMap, engine, solutionType, propsMap, }: {
     definitionsMap: TControllerDefinitionsMap;
     engine: SSRCommerceEngine;

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

@@ -0,0 +1,19 @@
+import { Action } from '@reduxjs/toolkit';
+import { Controller } from '../../../controllers/controller/headless-controller.js';
+import { CommerceEngine, CommerceEngineOptions } from '../../commerce-engine/commerce-engine.js';
+import { ControllerDefinitionsMap, SolutionType } from '../types/common.js';
+import { BuildParameters, CommerceControllerDefinitionsMap, EngineDefinitionOptions } from '../types/core-engine.js';
+/**
+ * The SSR commerce engine.
+ */
+export interface SSRCommerceEngine extends CommerceEngine {
+    /**
+     * Waits for the request to be completed and returns a promise that resolves to an `Action`.
+     */
+    waitForRequestCompletedAction(): Promise<Action>[];
+}
+export type CommerceEngineDefinitionOptions<TControllers extends ControllerDefinitionsMap<Controller> = ControllerDefinitionsMap<Controller>> = EngineDefinitionOptions<CommerceEngineOptions, TControllers>;
+export declare const buildFactory: <TControllerDefinitions extends CommerceControllerDefinitionsMap>(controllerDefinitions: TControllerDefinitions | undefined, options: CommerceEngineDefinitionOptions<TControllerDefinitions>) => <T extends SolutionType>(solutionType: T) => (...[buildOptions]: BuildParameters<TControllerDefinitions>) => Promise<{
+    engine: SSRCommerceEngine;
+    controllers: import("../types/common.js").InferControllersMapFromDefinition<TControllerDefinitions, T>;
+}>;

package/force-app/main/default/staticresources/coveoheadless/definitions/app/commerce-ssr-engine/factories/hydrated-state-factory.d.ts

@@ -0,0 +1,4 @@
+import { SolutionType } from '../types/common.js';
+import { HydrateStaticStateFunction, CommerceControllerDefinitionsMap } from '../types/core-engine.js';
+import { CommerceEngineDefinitionOptions } from './build-factory.js';
+export declare const hydratedStaticStateFactory: <TControllerDefinitions extends CommerceControllerDefinitionsMap>(controllerDefinitions: TControllerDefinitions | undefined, options: CommerceEngineDefinitionOptions<TControllerDefinitions>) => (solutionType: SolutionType) => HydrateStaticStateFunction<TControllerDefinitions>;

package/force-app/main/default/staticresources/coveoheadless/definitions/app/commerce-ssr-engine/factories/recommendation-hydrated-state-factory.d.ts

@@ -0,0 +1,3 @@
+import { HydrateStaticStateFunction, CommerceControllerDefinitionsMap } from '../types/core-engine.js';
+import { CommerceEngineDefinitionOptions } from './build-factory.js';
+export declare function hydratedRecommendationStaticStateFactory<TControllerDefinitions extends CommerceControllerDefinitionsMap>(controllerDefinitions: TControllerDefinitions | undefined, options: CommerceEngineDefinitionOptions<TControllerDefinitions>): HydrateStaticStateFunction<TControllerDefinitions>;

package/force-app/main/default/staticresources/coveoheadless/definitions/app/commerce-ssr-engine/factories/recommendation-static-state-factory.d.ts

@@ -0,0 +1,3 @@
+import { FetchStaticStateFunction, CommerceControllerDefinitionsMap } from '../types/core-engine.js';
+import { CommerceEngineDefinitionOptions } from './build-factory.js';
+export declare function fetchRecommendationStaticStateFactory<TControllerDefinitions extends CommerceControllerDefinitionsMap>(controllerDefinitions: TControllerDefinitions | undefined, options: CommerceEngineDefinitionOptions<TControllerDefinitions>): FetchStaticStateFunction<TControllerDefinitions>;

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

@@ -0,0 +1,4 @@
+import { SolutionType } from '../types/common.js';
+import { FetchStaticStateFunction, CommerceControllerDefinitionsMap } from '../types/core-engine.js';
+import { CommerceEngineDefinitionOptions } from './build-factory.js';
+export declare const fetchStaticStateFactory: <TControllerDefinitions extends CommerceControllerDefinitionsMap>(controllerDefinitions: TControllerDefinitions | undefined, options: CommerceEngineDefinitionOptions<TControllerDefinitions>) => (solutionType: SolutionType) => FetchStaticStateFunction<TControllerDefinitions>;

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

@@ -0,0 +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 { ControllerDefinitionsMap, EngineDefinitionControllersPropsOption, SolutionType } from './common.js';
+export interface BuildOptions<TEngineOptions> {
+    extend?: OptionsExtender<TEngineOptions>;
+}
+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.
+     */
+    (...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,13 +1,25 @@
+import { UnknownAction } from '@reduxjs/toolkit';
 import type { Controller } from '../../../controllers/controller/headless-controller.js';
 import type { InvalidControllerDefinition } from '../../../utils/errors.js';
-import { SSRCommerceEngine } from '../../commerce-engine/commerce-engine.ssr.js';
-import type { HasKey, InferControllerStaticStateMapFromControllers, InferControllerStaticStateFromController, InferControllerPropsMapFromDefinitions } from '../../ssr-engine/types/common.js';
-export type { InferControllerStaticStateFromController, InferControllerStaticStateMapFromControllers, InferControllerPropsMapFromDefinitions, };
+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, HydratedState, OptionsTuple, InferControllerStaticStateFromController, InferControllerStaticStateMapFromControllers, };
 export declare enum SolutionType {
     search = "search",
     listing = "listing",
-    standalone = "standalone"
+    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.
@@ -29,11 +41,18 @@ export interface ControllerDefinitionWithProps<TController extends Controller, T
      */
     buildWithProps(engine: SSRCommerceEngine, props: TProps, solutionType?: SolutionType): TController;
 }
+export interface EngineStaticState<TSearchAction extends UnknownAction, TControllers extends ControllerStaticStateMap> {
+    searchActions: TSearchAction[];
+    controllers: TControllers;
+}
 export type ControllerDefinition<TController extends Controller> = ControllerDefinitionWithoutProps<TController> | ControllerDefinitionWithProps<TController, unknown>;
 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]>;
@@ -41,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.
@@ -53,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
@@ -66,6 +216,10 @@ interface UniversalController {
      * @internal
      */
     [SolutionType.standalone]: true;
+    /**
+     * @internal
+     */
+    [SolutionType.recommendation]: true;
 }
 interface SearchOnlyController {
     /**
@@ -79,6 +233,12 @@ interface ListingOnlyController {
      */
     [SolutionType.listing]: true;
 }
+interface RecommendationOnlyController {
+    /**
+     * @internal
+     */
+    [SolutionType.recommendation]: true;
+}
 interface SearchAndListingController {
     /**
      * @internal
@@ -89,10 +249,25 @@ 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> & 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;

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

@@ -1,14 +1,16 @@
 import { UnknownAction } from '@reduxjs/toolkit';
 import type { Controller } from '../../../controllers/controller/headless-controller.js';
-import { SSRCommerceEngine } from '../../commerce-engine/commerce-engine.ssr.js';
+import { CommerceEngineDefinition } from '../../commerce-engine/commerce-engine.ssr.js';
 import { EngineConfiguration } from '../../engine-configuration.js';
 import { NavigatorContextProvider } from '../../navigatorContextProvider.js';
-import { Build } from '../../ssr-engine/types/build.js';
-import { InferControllerPropsMapFromDefinitions } from '../../ssr-engine/types/common.js';
-import { FetchStaticState } from '../../ssr-engine/types/fetch-static-state.js';
-import { HydrateStaticState } from '../../ssr-engine/types/hydrate-static-state.js';
-import { ControllerDefinitionsMap, InferControllersMapFromDefinition, SolutionType, InferControllerStaticStateMapFromDefinitionsWithSolutionType } from './common.js';
-export type { HydrateStaticState, FetchStaticState };
+import type { FromBuildResultOptions } from '../../ssr-engine/types/from-build-result.js';
+import { SSRCommerceEngine } from '../factories/build-factory.js';
+import { Build, BuildOptions } from './build.js';
+import { ControllerDefinitionsMap, InferControllersMapFromDefinition, SolutionType, InferControllerStaticStateMapFromDefinitionsWithSolutionType, InferControllerPropsMapFromDefinitions } from './common.js';
+import { FetchStaticState, FetchStaticStateOptions } from './fetch-static-state.js';
+import { FromBuildResult } from './from-build-result.js';
+import { HydrateStaticState, HydrateStaticStateOptions } from './hydrate-static-state.js';
+export type { FromBuildResult, FromBuildResultOptions, HydrateStaticState, HydrateStaticStateOptions, FetchStaticState, FetchStaticStateOptions, Build, BuildOptions, };
 export type EngineDefinitionOptions<TOptions extends {
     configuration: EngineConfiguration;
 }, TControllers extends ControllerDefinitionsMap<Controller>> = TOptions & {
@@ -21,15 +23,15 @@ export interface EngineDefinition<TControllers extends ControllerDefinitionsMap<
     /**
      * Fetches the static state on the server side using your engine definition.
      */
-    fetchStaticState: FetchStaticState<SSRCommerceEngine, InferControllersMapFromDefinition<TControllers, TSolutionType>, UnknownAction, InferControllerStaticStateMapFromDefinitionsWithSolutionType<TControllers, TSolutionType>, InferControllerPropsMapFromDefinitions<TControllers>>;
+    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<SSRCommerceEngine, InferControllersMapFromDefinition<TControllers, TSolutionType>, UnknownAction, InferControllerPropsMapFromDefinitions<TControllers>>;
+    hydrateStaticState: HydrateStaticState<InferControllersMapFromDefinition<TControllers, TSolutionType>, UnknownAction, InferControllerPropsMapFromDefinitions<TControllers>, TControllers, TSolutionType>;
     /**
      * Builds an engine and its controllers from an engine definition.
      */
-    build: Build<SSRCommerceEngine, TEngineOptions, InferControllersMapFromDefinition<TControllers, TSolutionType>, InferControllerPropsMapFromDefinitions<TControllers>>;
+    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.
@@ -47,3 +49,20 @@ export type InferHydratedState<T extends {
 export type InferBuildResult<T extends {
     build(...args: unknown[]): Promise<unknown>;
 }> = Awaited<ReturnType<T['build']>>;
+export type CommerceControllerDefinitionsMap = ControllerDefinitionsMap<Controller>;
+type Definition<TControllerDefinitions extends CommerceControllerDefinitionsMap> = CommerceEngineDefinition<TControllerDefinitions, SolutionType>;
+export type BuildFunction<TControllerDefinitions extends CommerceControllerDefinitionsMap> = Definition<TControllerDefinitions>['build'];
+export type FetchStaticStateFunction<TControllerDefinitions extends CommerceControllerDefinitionsMap> = Definition<TControllerDefinitions>['fetchStaticState'];
+export type HydrateStaticStateFunction<TControllerDefinitions extends CommerceControllerDefinitionsMap> = Definition<TControllerDefinitions>['hydrateStaticState'];
+export type FetchStaticStateFromBuildResultFunction<TControllerDefinitions extends CommerceControllerDefinitionsMap> = FetchStaticStateFunction<TControllerDefinitions>['fromBuildResult'];
+export type HydrateStaticStateFromBuildResultFunction<TControllerDefinitions extends CommerceControllerDefinitionsMap> = HydrateStaticStateFunction<TControllerDefinitions>['fromBuildResult'];
+export type BuildParameters<TControllerDefinitions extends CommerceControllerDefinitionsMap> = Parameters<BuildFunction<TControllerDefinitions>>;
+export type FetchStaticStateParameters<TControllerDefinitions extends CommerceControllerDefinitionsMap> = Parameters<FetchStaticStateFunction<TControllerDefinitions>>;
+export type HydrateStaticStateParameters<TControllerDefinitions extends CommerceControllerDefinitionsMap> = Parameters<HydrateStaticStateFunction<TControllerDefinitions>>;
+export type FetchStaticStateFromBuildResultParameters<TControllerDefinitions extends CommerceControllerDefinitionsMap> = Parameters<FetchStaticStateFromBuildResultFunction<TControllerDefinitions>>;
+export type HydrateStaticStateFromBuildResultParameters<TControllerDefinitions extends CommerceControllerDefinitionsMap> = Parameters<HydrateStaticStateFromBuildResultFunction<TControllerDefinitions>>;
+export type Controllers<TControllerDefinitions extends CommerceControllerDefinitionsMap> = InferControllersMapFromDefinition<TControllerDefinitions, SolutionType>;
+export type BuildResult<TControllerDefinitions extends CommerceControllerDefinitionsMap> = {
+    engine: SSRCommerceEngine;
+    controllers: Controllers<TControllerDefinitions>;
+};

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

@@ -0,0 +1,15 @@
+import type { UnknownAction } from '@reduxjs/toolkit';
+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, 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.
+     */
+    (...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

@@ -0,0 +1,20 @@
+import { ControllersMap } from '../../ssr-engine/types/common.js';
+import { SSRCommerceEngine } from '../factories/build-factory.js';
+import { EngineDefinitionBuildResult } from './common.js';
+export interface FromBuildResultOptions<TControllers extends ControllersMap> {
+    /**
+     * The build result of the engine
+     */
+    buildResult: EngineDefinitionBuildResult<SSRCommerceEngine, TControllers>;
+    /**
+     * An optional array of keys representing the recommendation controllers to refresh.
+     * If a recommendation key defined in your engine definition is present in this list, the associate recommendation controller
+     * will query the API.
+     *
+     * This is applicable only if the engine is a recommendation engine.
+     */
+    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

@@ -0,0 +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 { 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, 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> & 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/logger.d.ts

@@ -11,4 +11,4 @@ export interface LoggerOptions {
      */
     logFormatter?: (object: {}) => {};
 }
-export declare function buildLogger(options: LoggerOptions | undefined): import("pino").Logger<never>;
+export declare function buildLogger(options: LoggerOptions | undefined): import("pino").Logger<never, boolean>;