@coveo/quantic 3.30.3-pre.b400a05b95 → 3.30.3-pre.bfb80506e9

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

@@ -1,14 +1,16 @@
 import type { ThunkDispatch, UnknownAction } from '@reduxjs/toolkit';
+import type { AnswerApiQueryParams } from '../../features/generated-answer/generated-answer-request.js';
 import type { EventSourceMessage } from '../../utils/fetch-event-source/parse.js';
-import type { SearchRequest } from '../search/search/search-request.js';
 import type { GeneratedAnswerStream } from './generated-answer-stream.js';
 import type { StreamAnswerAPIState } from './stream-answer-api-state.js';
 export declare const updateCacheWithEvent: (event: EventSourceMessage, draft: GeneratedAnswerStream, dispatch: ThunkDispatch<StreamAnswerAPIState, unknown, UnknownAction>) => void;
 export declare const answerApi: import("@reduxjs/toolkit/query").Api<import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@reduxjs/toolkit/query").FetchArgs, unknown, import("@reduxjs/toolkit/query").FetchBaseQueryError, {} & import("@reduxjs/toolkit/query").RetryOptions, {}>, {
-    getAnswer: import("@reduxjs/toolkit/query").QueryDefinition<Partial<SearchRequest>, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@reduxjs/toolkit/query").FetchArgs, unknown, import("@reduxjs/toolkit/query").FetchBaseQueryError, {} & import("@reduxjs/toolkit/query").RetryOptions, {}>, never, GeneratedAnswerStream, "answer">;
+    getAnswer: import("@reduxjs/toolkit/query").QueryDefinition<AnswerApiQueryParams, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@reduxjs/toolkit/query").FetchArgs, unknown, import("@reduxjs/toolkit/query").FetchBaseQueryError, {} & import("@reduxjs/toolkit/query").RetryOptions, {}>, never, GeneratedAnswerStream, "answer">;
 }, "answer", never, typeof import("@reduxjs/toolkit/query").coreModuleName>;
-export declare const fetchAnswer: (fetchAnswerParams: Partial<SearchRequest>) => import("redux-thunk").ThunkAction<import("@reduxjs/toolkit/query").QueryActionCreatorResult<import("@reduxjs/toolkit/query").QueryDefinition<Partial<SearchRequest>, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@reduxjs/toolkit/query").FetchArgs, unknown, import("@reduxjs/toolkit/query").FetchBaseQueryError, {} & import("@reduxjs/toolkit/query").RetryOptions, {}>, never, GeneratedAnswerStream, "answer">>, any, any, UnknownAction>;
-export declare const selectAnswer: (state: StreamAnswerAPIState) => ({
+export declare const fetchAnswer: (fetchAnswerParams: AnswerApiQueryParams) => import("redux-thunk").ThunkAction<import("@reduxjs/toolkit/query").QueryActionCreatorResult<import("@reduxjs/toolkit/query").QueryDefinition<AnswerApiQueryParams, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@reduxjs/toolkit/query").FetchArgs, unknown, import("@reduxjs/toolkit/query").FetchBaseQueryError, {} & import("@reduxjs/toolkit/query").RetryOptions, {}>, never, GeneratedAnswerStream, "answer">>, any, any, UnknownAction>;
+export declare const selectAnswer: (selectAnswerParams: AnswerApiQueryParams) => (state: import("@reduxjs/toolkit/query").RootState<{
+    getAnswer: import("@reduxjs/toolkit/query").QueryDefinition<AnswerApiQueryParams, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@reduxjs/toolkit/query").FetchArgs, unknown, import("@reduxjs/toolkit/query").FetchBaseQueryError, {} & import("@reduxjs/toolkit/query").RetryOptions, {}>, never, GeneratedAnswerStream, "answer">;
+}, never, "answer">) => ({
     status: import("@reduxjs/toolkit/query").QueryStatus.uninitialized;
     originalArgs?: undefined | undefined;
     data?: undefined | undefined;
@@ -27,7 +29,7 @@ export declare const selectAnswer: (state: StreamAnswerAPIState) => ({
     status: import("@reduxjs/toolkit/query").QueryStatus.fulfilled;
     error: undefined;
     endpointName: string;
-    originalArgs: Partial<SearchRequest>;
+    originalArgs: AnswerApiQueryParams;
     requestId: string;
     startedTimeStamp: number;
     data: GeneratedAnswerStream;
@@ -40,7 +42,7 @@ export declare const selectAnswer: (state: StreamAnswerAPIState) => ({
     isError: false;
 }) | ({
     status: import("@reduxjs/toolkit/query").QueryStatus.pending;
-    originalArgs: Partial<SearchRequest>;
+    originalArgs: AnswerApiQueryParams;
     requestId: string;
     data?: GeneratedAnswerStream | undefined;
     error?: import("@reduxjs/toolkit").SerializedError | import("@reduxjs/toolkit/query").FetchBaseQueryError | undefined;
@@ -58,7 +60,7 @@ export declare const selectAnswer: (state: StreamAnswerAPIState) => ({
     data?: GeneratedAnswerStream | undefined;
     endpointName: string;
     fulfilledTimeStamp?: number | undefined;
-    originalArgs: Partial<SearchRequest>;
+    originalArgs: AnswerApiQueryParams;
     requestId: string;
     startedTimeStamp: number;
     error: import("@reduxjs/toolkit").SerializedError | import("@reduxjs/toolkit/query").FetchBaseQueryError;

package/force-app/main/default/staticresources/coveoheadless/definitions/api/search/search-api-params.d.ts

@@ -110,7 +110,7 @@ type GenQAParameters = {
     responseFormat: ResponseFormatParameters;
     citationsFieldToInclude: string[];
 };
-type ResponseFormatParameters = {
+export type ResponseFormatParameters = {
     contentFormat?: GeneratedContentFormat[];
 };
 export declare const baseSearchRequest: (req: BaseParam & AuthenticationParam, method: HttpMethods, contentType: HTTPContentType, path: string) => Pick<PlatformClientCallOptions, "accessToken" | "method" | "contentType" | "url" | "origin">;

package/force-app/main/default/staticresources/coveoheadless/definitions/features/configuration/configuration-selectors.d.ts

@@ -0,0 +1,51 @@
+import type { ConfigurationState } from './configuration-state.js';
+export declare const selectLocale: ((state: {
+    configuration: ConfigurationState;
+}) => string) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: string) => string;
+    memoizedResultFunc: ((resultFuncArgs_0: string) => string) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => string;
+    dependencies: [(state: {
+        configuration: ConfigurationState;
+    }) => string];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const selectTimezone: ((state: {
+    configuration: ConfigurationState;
+}) => string) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: string) => string;
+    memoizedResultFunc: ((resultFuncArgs_0: string) => string) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => string;
+    dependencies: [(state: {
+        configuration: ConfigurationState;
+    }) => string];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};

package/force-app/main/default/staticresources/coveoheadless/definitions/features/dictionary-field-context/dictionary-field-context-selectors.d.ts

@@ -0,0 +1,4 @@
+import type { DictionaryFieldContextState } from './dictionary-field-context-state.js';
+export declare const selectDictionaryFieldContext: (state: {
+    dictionaryFieldContext?: DictionaryFieldContextState;
+}) => import("./dictionary-field-context-state.js").DictionaryFieldContextPayload | undefined;

package/force-app/main/default/staticresources/coveoheadless/definitions/features/excerpt-length/excerpt-length-selectors.d.ts

@@ -0,0 +1,26 @@
+import type { ExcerptLengthState } from './excerpt-length-state.js';
+export declare const selectExcerptLength: ((state: {
+    excerptLength?: ExcerptLengthState;
+}) => number | undefined) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: number | undefined) => number | undefined;
+    memoizedResultFunc: ((resultFuncArgs_0: number | undefined) => number | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => number | undefined;
+    dependencies: [(state: {
+        excerptLength?: ExcerptLengthState;
+    }) => number | undefined];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};

package/force-app/main/default/staticresources/coveoheadless/definitions/features/facet-options/facet-options-selectors.d.ts

@@ -1,2 +1,9 @@
 import type { FacetOptionsSection } from '../../state/state-sections.js';
 export declare const isFacetEnabledSelector: (state: FacetOptionsSection, id: string) => boolean;
+export declare const selectFacetOptions: (state: {
+    facetOptions?: {
+        freezeFacetOrder?: boolean;
+    };
+}) => {
+    freezeFacetOrder: boolean;
+} | undefined;

package/force-app/main/default/staticresources/coveoheadless/definitions/features/folding/folding-selectors.d.ts

@@ -0,0 +1,9 @@
+import type { FoldingState } from './folding-state.js';
+export declare const selectFoldingQueryParams: (state: {
+    folding?: FoldingState;
+}) => {
+    filterField: string;
+    childField: string;
+    parentField: string;
+    filterFieldRange: number;
+} | undefined;

package/force-app/main/default/staticresources/coveoheadless/definitions/features/generated-answer/generated-answer-actions.d.ts

@@ -1,7 +1,7 @@
 import type { GeneratedAnswerCitationsPayload, GeneratedAnswerMessagePayload } from '../../api/generated-answer/generated-answer-event-payload.js';
 import type { StreamAnswerAPIState } from '../../api/knowledge/stream-answer-api-state.js';
-import type { SearchRequest } from '../../api/search/search/search-request.js';
 import type { SearchThunkExtraArguments } from '../../app/search-thunk-extra-arguments.js';
+import type { AnswerApiQueryParams } from '../../features/generated-answer/generated-answer-request.js';
 import type { ConfigurationSection, DebugSection, GeneratedAnswerSection, SearchSection } from '../../state/state-sections.js';
 import { type GeneratedResponseFormat } from './generated-response-format.js';
 type StateNeededByGeneratedAnswerStream = ConfigurationSection & SearchSection & GeneratedAnswerSection & DebugSection;
@@ -35,7 +35,7 @@ export declare const updateAnswerConfigurationId: import("@reduxjs/toolkit").Act
 export declare const registerFieldsToIncludeInCitations: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[payload: string[]], string[], "generatedAnswer/registerFieldsToIncludeInCitations", never, never>;
 export declare const setIsAnswerGenerated: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[payload: boolean], boolean, "generatedAnswer/setIsAnswerGenerated", never, never>;
 export declare const setCannotAnswer: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[payload: boolean], boolean, "generatedAnswer/setCannotAnswer", never, never>;
-export declare const setAnswerApiQueryParams: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[payload: Partial<SearchRequest>], unknown, "generatedAnswer/setAnswerApiQueryParams", never, never>;
+export declare const setAnswerApiQueryParams: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[payload: AnswerApiQueryParams], unknown, "generatedAnswer/setAnswerApiQueryParams", never, never>;
 interface StreamAnswerArgs {
     setAbortControllerRef: (ref: AbortController) => void;
 }

package/force-app/main/default/staticresources/coveoheadless/definitions/features/generated-answer/generated-answer-mocks.d.ts

@@ -0,0 +1,209 @@
+/** biome-ignore-all lint/suspicious/noExplicitAny: <mock> */
+import type { StreamAnswerAPIState } from '../../api/knowledge/stream-answer-api-state.js';
+export declare const streamAnswerAPIStateMock: StreamAnswerAPIState;
+export declare const streamAnswerAPIStateMockWithATabWithAnExpression: StreamAnswerAPIState;
+export declare const streamAnswerAPIStateMockWithoutAnyTab: StreamAnswerAPIState;
+export declare const streamAnswerAPIStateMockWithStaticFiltersSelected: StreamAnswerAPIState;
+export declare const streamAnswerAPIStateMockWithNonValidFilters: StreamAnswerAPIState;
+export declare const streamAnswerAPIStateMockWithoutAnyFilters: StreamAnswerAPIState;
+export declare const streamAnswerAPIStateMockWithStaticFiltersAndTabExpression: StreamAnswerAPIState;
+export declare const streamAnswerAPIStateMockWithStaticFiltersAndTabExpressionWithEmptyCQ: {
+    advancedSearchQueries: {
+        cq: string;
+        cqWasSet: boolean;
+        aq: string;
+        aqWasSet: boolean;
+        lq: string;
+        lqWasSet: boolean;
+        dq: string;
+        dqWasSet: boolean;
+        defaultFilters: {
+            cq: string;
+            aq: string;
+            lq: string;
+            dq: string;
+        };
+    };
+    searchHub: string;
+    pipeline: string;
+    answer: import("@reduxjs/toolkit/query").CombinedState<{
+        getAnswer: import("@reduxjs/toolkit/query").QueryDefinition<Partial<import("../../api/search/search/search-request.js").SearchRequest>, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@reduxjs/toolkit/query").FetchArgs, unknown, import("@reduxjs/toolkit/query").FetchBaseQueryError, {} & import("@reduxjs/toolkit/query").RetryOptions, {}>, never, import("../../api/knowledge/generated-answer-stream.js").GeneratedAnswerStream, "answer">;
+    }, never, "answer">;
+    configuration: import("../configuration/configuration-state.js").ConfigurationState;
+    facetSet?: import("../facets/facet-set/facet-set-state.js").FacetSetState | undefined;
+    dateFacetSet?: import("../facets/range-facets/date-facet-set/date-facet-set-state.js").DateFacetSetState | undefined;
+    numericFacetSet?: import("../facets/range-facets/numeric-facet-set/numeric-facet-set-state.js").NumericFacetSetState | undefined;
+    categoryFacetSet?: import("../facets/category-facet-set/category-facet-set-state.js").CategoryFacetSetState | undefined;
+    automaticFacetSet?: import("../facets/automatic-facet-set/automatic-facet-set-state.js").AutomaticFacetSetState | undefined;
+    facetOptions?: import("../facet-options/facet-options-state.js").FacetOptionsState | undefined;
+    query?: import("../query/query-state.js").QueryState | undefined;
+    tabSet?: import("../tab-set/tab-set-state.js").TabSetState | undefined;
+    staticFilterSet?: import("../static-filter-set/static-filter-set-state.js").StaticFilterSetState | undefined;
+    pagination?: import("../pagination/pagination-state.js").PaginationState | undefined;
+    sortCriteria?: string | undefined;
+    context?: import("../context/context-state.js").ContextState | undefined;
+    dictionaryFieldContext?: import("../dictionary-field-context/dictionary-field-context-state.js").DictionaryFieldContextState | undefined;
+    querySet?: import("../query-set/query-set-state.js").QuerySetState | undefined;
+    debug?: boolean | undefined;
+    facetSearchSet?: import("../facets/facet-search-set/specific/specific-facet-search-set-state.js").SpecificFacetSearchSetState | undefined;
+    categoryFacetSearchSet?: import("../facets/facet-search-set/category/category-facet-search-set-state.js").CategoryFacetSearchSetState | undefined;
+    standaloneSearchBoxSet?: import("../standalone-search-box-set/standalone-search-box-set-state.js").StandaloneSearchBoxSetState | undefined;
+    querySuggest?: import("../query-suggest/query-suggest-state.js").QuerySuggestSet | undefined;
+    search?: import("../search/search-state.js").SearchState | undefined;
+    resultPreview?: import("../result-preview/result-preview-state.js").ResultPreviewState | undefined;
+    didYouMean?: import("../did-you-mean/did-you-mean-state.js").DidYouMeanState | undefined;
+    fields?: import("../fields/fields-state.js").FieldsState | undefined;
+    facetOrder?: import("../facets/facet-order/facet-order-state.js").FacetOrderState | undefined;
+    version?: string | undefined;
+    history?: import("../../app/undoable.js").StateWithHistory<import("../history/history-state.js").HistoryState> | undefined;
+    folding?: import("../folding/folding-state.js").FoldingState | undefined;
+    triggers?: import("../triggers/triggers-state.js").TriggerState | undefined;
+    questionAnswering?: import("../question-answering/question-answering-state.js").QuestionAnsweringState | undefined;
+    recentResults?: import("../recent-results/recent-results-state.js").RecentResultsState | undefined;
+    recentQueries?: import("../recent-queries/recent-queries-state.js").RecentQueriesState | undefined;
+    excerptLength?: import("../excerpt-length/excerpt-length-state.js").ExcerptLengthState | undefined;
+    generatedAnswer: import("./generated-answer-state.js").GeneratedAnswerState;
+    instantResults?: import("../instant-results/instant-results-state.js").InstantResultsState | undefined;
+    insightConfiguration?: import("../insight-configuration/insight-configuration-state.js").InsightConfigurationState | undefined;
+};
+export declare const streamAnswerAPIStateMockWithoutSearchAction: StreamAnswerAPIState;
+export declare const streamAnswerAPIStateMockWithAnalyticsEnabled: StreamAnswerAPIState;
+export declare const streamAnswerAPIStateMockWithFoldingDisabled: StreamAnswerAPIState;
+export declare const streamAnswerAPIStateMockWithFoldingEnabled: StreamAnswerAPIState;
+export declare const streamAnswerAPIStateMockWithDictionaryFieldContext: StreamAnswerAPIState;
+export declare const streamAnswerAPIStateMockWithExcerptLength: StreamAnswerAPIState;
+export declare const streamAnswerAPIStateMockWithQuerySyntaxEnabled: StreamAnswerAPIState;
+export declare const expectedStreamAnswerAPIParam: {
+    q: string;
+    aq: string;
+    cq: string;
+    dq: string;
+    lq: string;
+    enableQuerySyntax: boolean;
+    context: {
+        testKey: string;
+    };
+    pipelineRuleParameters: {
+        mlGenerativeQuestionAnswering: {
+            responseFormat: {
+                contentFormat: string[];
+            };
+            citationsFieldToInclude: never[];
+        };
+    };
+    searchHub: string;
+    facets: ({
+        filterFacetCount: boolean;
+        injectionDepth: number;
+        numberOfValues: number;
+        sortCriteria: string;
+        resultsMustMatch: string;
+        type: string;
+        currentValues: never[];
+        freezeCurrentValues: boolean;
+        isFieldExpanded: boolean;
+        preventAutoSelect: boolean;
+        facetId: string;
+        field: string;
+        rangeAlgorithm?: undefined;
+        generateAutomaticRanges?: undefined;
+        delimitingCharacter?: undefined;
+        basePath?: undefined;
+        filterByBasePath?: undefined;
+    } | {
+        filterFacetCount: boolean;
+        injectionDepth: number;
+        numberOfValues: number;
+        sortCriteria: string;
+        rangeAlgorithm: string;
+        resultsMustMatch: string;
+        currentValues: {
+            start: string;
+            end: string;
+            endInclusive: boolean;
+            state: string;
+        }[];
+        preventAutoSelect: boolean;
+        type: string;
+        facetId: string;
+        field: string;
+        generateAutomaticRanges: boolean;
+        freezeCurrentValues?: undefined;
+        isFieldExpanded?: undefined;
+        delimitingCharacter?: undefined;
+        basePath?: undefined;
+        filterByBasePath?: undefined;
+    } | {
+        delimitingCharacter: string;
+        filterFacetCount: boolean;
+        injectionDepth: number;
+        numberOfValues: number;
+        sortCriteria: string;
+        basePath: never[];
+        filterByBasePath: boolean;
+        resultsMustMatch: string;
+        currentValues: never[];
+        preventAutoSelect: boolean;
+        type: string;
+        facetId: string;
+        field: string;
+        freezeCurrentValues?: undefined;
+        isFieldExpanded?: undefined;
+        rangeAlgorithm?: undefined;
+        generateAutomaticRanges?: undefined;
+    } | {
+        filterFacetCount: boolean;
+        injectionDepth: number;
+        numberOfValues: number;
+        sortCriteria: string;
+        rangeAlgorithm: string;
+        resultsMustMatch: string;
+        currentValues: {
+            endInclusive: boolean;
+            state: string;
+            start: number;
+            end: number;
+        }[];
+        preventAutoSelect: boolean;
+        type: string;
+        facetId: string;
+        field: string;
+        generateAutomaticRanges: boolean;
+        freezeCurrentValues?: undefined;
+        isFieldExpanded?: undefined;
+        delimitingCharacter?: undefined;
+        basePath?: undefined;
+        filterByBasePath?: undefined;
+    })[];
+    fieldsToInclude: string[];
+    queryCorrection: {
+        enabled: boolean;
+        options: {
+            automaticallyCorrect: string;
+        };
+    };
+    enableDidYouMean: boolean;
+    numberOfResults: number;
+    firstResult: number;
+    tab: string;
+    locale: string;
+    timezone: string;
+    referrer: string;
+    debug: boolean;
+    actionsHistory: never[];
+    sortCriteria: string;
+    facetOptions: {
+        freezeFacetOrder: boolean;
+    };
+    analytics: {
+        actionCause: string;
+        capture: boolean;
+        clientId: string;
+        clientTimestamp: string;
+        customData: undefined;
+        documentLocation: string;
+        documentReferrer: string;
+        originContext: string;
+        source: string[];
+    };
+};

package/force-app/main/default/staticresources/coveoheadless/definitions/features/generated-answer/generated-answer-request.d.ts

@@ -1,69 +1,58 @@
+import type { HistoryElement } from '../../api/analytics/coveo.analytics/history-store.js';
 import type { GeneratedAnswerStreamRequest } from '../../api/generated-answer/generated-answer-request.js';
 import type { StreamAnswerAPIState } from '../../api/knowledge/stream-answer-api-state.js';
+import type { AnalyticsParam, ResponseFormatParameters } from '../../api/search/search-api-params.js';
 import type { NavigatorContext } from '../../app/navigator-context-provider.js';
 import type { ConfigurationSection, GeneratedAnswerSection, SearchSection } from '../../state/state-sections.js';
+import type { ContextPayload } from '../context/context-state.js';
+import type { FacetOptions } from '../facet-options/facet-options.js';
+import type { AnyFacetRequest } from '../facets/generic/interfaces/generic-facet-request.js';
 type StateNeededByGeneratedAnswerStream = ConfigurationSection & SearchSection & GeneratedAnswerSection;
-export declare const buildStreamingRequest: (state: StateNeededByGeneratedAnswerStream) => Promise<GeneratedAnswerStreamRequest>;
-export declare const constructAnswerAPIQueryParams: (state: StreamAnswerAPIState, navigatorContext: NavigatorContext) => {
-    analytics?: {
-        actionCause?: string;
-        customData?: object;
-        clientId: string;
-        deviceId?: string;
-        pageId?: string;
-        clientTimestamp: string;
-        documentReferrer: string | null;
-        originContext: string;
-        userDisplayName?: string;
-        documentLocation?: string | null;
-        trackingId?: string;
-        capture?: boolean;
-        source?: string[];
+export interface AnswerApiQueryParams {
+    q?: string;
+    aq?: string;
+    cq?: string;
+    dq?: string;
+    lq?: string;
+    enableQuerySyntax?: boolean;
+    context?: ContextPayload;
+    pipelineRuleParameters?: {
+        mlGenerativeQuestionAnswering: {
+            responseFormat: ResponseFormatParameters;
+            citationsFieldToInclude: string[];
+        };
     };
-    tab: string;
-    numberOfResults?: number | undefined;
-    firstResult?: number | undefined;
+    searchHub?: string;
+    pipeline?: string;
+    facets?: AnyFacetRequest[];
+    fieldsToInclude?: string[];
     queryCorrection?: {
         enabled: boolean;
         options: {
-            automaticallyCorrect: "never" | "whenNoResults";
-        };
-    } | undefined;
-    enableDidYouMean?: boolean | undefined;
-    fieldsToInclude?: string[] | undefined;
-    facets?: (import("../facets/facet-set/interfaces/request.js").FacetRequest | import("../facets/category-facet-set/interfaces/request.js").CategoryFacetRequest | import("../facets/range-facets/numeric-facet-set/interfaces/request.js").NumericFacetRequest | {
-        currentValues: {
-            start: string;
-            end: string;
-            endInclusive: boolean;
-            state: import("../../ssr.index.js").FacetValueState;
-            previousState?: import("../../ssr.index.js").FacetValueState;
-        }[];
-        sortCriteria: import("../../ssr.index.js").RangeFacetSortCriterion;
-        rangeAlgorithm: import("../../ssr.index.js").RangeFacetRangeAlgorithm;
-        facetId: string;
-        field: string;
-        filterFacetCount: boolean;
-        injectionDepth: number;
-        numberOfValues: number;
-        preventAutoSelect: boolean;
-        resultsMustMatch: import("../../ssr.index.js").FacetResultsMustMatch;
-        generateAutomaticRanges: boolean;
-        type: "dateRange";
-    })[] | undefined;
-    pipeline?: string | undefined;
-    searchHub?: string | undefined;
-    pipelineRuleParameters: {
-        mlGenerativeQuestionAnswering: {
-            responseFormat: import("./generated-response-format.js").GeneratedResponseFormat;
-            citationsFieldToInclude: string[];
+            automaticallyCorrect: 'whenNoResults' | 'never';
         };
     };
-    context?: import("../context/context-state.js").ContextPayload | undefined;
-    lq?: string | undefined;
-    dq?: string | undefined;
-    cq?: string | undefined;
-    aq?: string | undefined;
-    q: string | undefined;
-};
+    enableDidYouMean?: boolean;
+    numberOfResults?: number;
+    firstResult?: number;
+    tab?: string;
+    locale?: string;
+    timezone?: string;
+    debug?: boolean;
+    referrer?: string;
+    actionsHistory?: HistoryElement[];
+    foldingParams?: {
+        filterField: string;
+        childField: string;
+        parentField: string;
+        filterFieldRange: number;
+    };
+    excerptLength?: number;
+    dictionaryFieldContext?: Record<string, string>;
+    sortCriteria?: string;
+    facetOptions?: FacetOptions;
+    analytics?: AnalyticsParam['analytics'];
+}
+export declare const buildStreamingRequest: (state: StateNeededByGeneratedAnswerStream) => Promise<GeneratedAnswerStreamRequest>;
+export declare const constructAnswerAPIQueryParams: (state: StreamAnswerAPIState, navigatorContext: NavigatorContext) => AnswerApiQueryParams;
 export {};

package/force-app/main/default/staticresources/coveoheadless/definitions/features/generated-answer/generated-answer-state.d.ts

@@ -1,5 +1,5 @@
 import type { GeneratedAnswerCitation } from '../../api/generated-answer/generated-answer-event-payload.js';
-import type { SearchRequest } from '../../api/search/search/search-request.js';
+import type { AnswerApiQueryParams } from '../../features/generated-answer/generated-answer-request.js';
 import type { GeneratedContentFormat, GeneratedResponseFormat } from './generated-response-format.js';
 /**
  * A scoped and simplified part of the headless state that is relevant to the `GeneratedAnswer` component.
@@ -90,6 +90,6 @@ export interface GeneratedAnswerState {
     /**
      * The query parameters used for the answer API request cache key
      */
-    answerApiQueryParams?: Partial<SearchRequest>;
+    answerApiQueryParams?: AnswerApiQueryParams;
 }
 export declare function getGeneratedAnswerInitialState(): GeneratedAnswerState;

package/force-app/main/default/staticresources/coveoheadless/definitions/features/query/query-selectors.d.ts

@@ -24,3 +24,28 @@ export declare const selectQuery: ((state: {
     argsMemoize: typeof import("reselect").weakMapMemoize;
     memoize: typeof import("reselect").weakMapMemoize;
 };
+export declare const selectEnableQuerySyntax: ((state: {
+    query?: QueryState;
+}) => boolean | undefined) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: boolean | undefined) => boolean | undefined;
+    memoizedResultFunc: ((resultFuncArgs_0: boolean | undefined) => boolean | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean | undefined;
+    dependencies: [(state: {
+        query?: QueryState;
+    }) => boolean | undefined];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};

package/force-app/main/default/staticresources/coveoheadless/definitions/features/search/legacy/search-request.d.ts

@@ -6,9 +6,7 @@ type StateNeededBySearchRequest = ConfigurationSection & Partial<SearchAppState>
 export declare const buildSearchRequest: (state: StateNeededBySearchRequest, eventDescription?: EventDescription) => Promise<import("../search-mappings.js").MappedSearchRequest<{
     pipelineRuleParameters?: {
         mlGenerativeQuestionAnswering?: {
-            responseFormat: {
-                contentFormat?: import("../../generated-answer/generated-response-format.js").GeneratedContentFormat[];
-            };
+            responseFormat: import("../../../api/search/search-api-params.js").ResponseFormatParameters;
             citationsFieldToInclude: string[];
         };
     };

package/force-app/main/default/staticresources/coveoheadless/definitions/features/search/search-request.d.ts

@@ -7,9 +7,7 @@ type StateNeededBySearchRequest = ConfigurationSection & Partial<SearchAppState>
 export declare const buildSearchRequest: (state: StateNeededBySearchRequest, navigatorContext: NavigatorContext, eventDescription?: EventDescription) => Promise<import("./search-mappings.js").MappedSearchRequest<{
     pipelineRuleParameters?: {
         mlGenerativeQuestionAnswering?: {
-            responseFormat: {
-                contentFormat?: import("../generated-answer/generated-response-format.js").GeneratedContentFormat[];
-            };
+            responseFormat: import("../../api/search/search-api-params.js").ResponseFormatParameters;
             citationsFieldToInclude: string[];
         };
     };

package/force-app/main/default/staticresources/coveoheadless/definitions/features/sort-criteria/sort-criteria-selectors.d.ts

@@ -0,0 +1,26 @@
+import type { SortCriteriaState } from './sort-criteria-state.js';
+export declare const selectSortCriteria: ((state: {
+    sortCriteria?: SortCriteriaState;
+}) => string | undefined) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: string | undefined) => string | undefined;
+    memoizedResultFunc: ((resultFuncArgs_0: string | undefined) => string | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => string | undefined;
+    dependencies: [(state: {
+        sortCriteria?: SortCriteriaState;
+    }) => string | undefined];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};

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

@@ -1,7 +1,7 @@
 import type { Action } from '@reduxjs/toolkit';
 import { type CommerceEngine } from '../../../app/commerce-engine/commerce-engine.js';
 import { SolutionType } from '../types/controller-constants.js';
-import type { AugmentedControllerDefinition, BakedInControllers } from '../types/controller-definitions.js';
+import type { BakedInControllers } from '../types/controller-definitions.js';
 import type { InferControllersMapFromDefinition } from '../types/controller-inference.js';
 import type { CommerceControllerDefinitionsMap, CommerceEngineDefinitionOptions, FetchStaticStateParameters, HydrateStaticStateParameters } from '../types/engine.js';
 /**
@@ -15,7 +15,7 @@ export interface SSRCommerceEngine extends CommerceEngine {
      */
     waitForRequestCompletedAction(): Promise<Action>[];
 }
-export declare const buildFactory: <TControllerDefinitions extends CommerceControllerDefinitionsMap>(controllerDefinitions: AugmentedControllerDefinition<TControllerDefinitions>, options: CommerceEngineDefinitionOptions<TControllerDefinitions>) => <TSolutionType extends SolutionType>(solutionType: TSolutionType) => (...[buildOptions]: FetchStaticStateParameters<TControllerDefinitions, TSolutionType> | HydrateStaticStateParameters<TControllerDefinitions, TSolutionType>) => Promise<{
+export declare const buildFactory: <TControllerDefinitions extends CommerceControllerDefinitionsMap>(controllerDefinitions: TControllerDefinitions, options: CommerceEngineDefinitionOptions<TControllerDefinitions>) => <TSolutionType extends SolutionType>(solutionType: TSolutionType) => (...[buildOptions]: FetchStaticStateParameters<TControllerDefinitions, TSolutionType> | HydrateStaticStateParameters<TControllerDefinitions, TSolutionType>) => Promise<{
     engine: SSRCommerceEngine;
     controllers: InferControllersMapFromDefinition<TControllerDefinitions, TSolutionType> & BakedInControllers;
 }>;

package/force-app/main/default/staticresources/coveoheadless/definitions/test/mock-search-request.d.ts

@@ -60,9 +60,7 @@ export declare function buildMockSearchRequest(config?: Partial<SearchRequest>):
     };
     pipelineRuleParameters?: {
         mlGenerativeQuestionAnswering?: {
-            responseFormat: {
-                contentFormat?: import("../index.js").GeneratedContentFormat[];
-            };
+            responseFormat: import("../api/search/search-api-params.js").ResponseFormatParameters;
             citationsFieldToInclude: string[];
         };
     };