@coveo/quantic 3.30.3-pre.fca9d855d9 → 3.30.3-pre.fffcaa9cfe

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-request.d.ts

@@ -20,7 +20,22 @@ export declare const constructAnswerAPIQueryParams: (state: StreamAnswerAPIState
         capture?: boolean;
         source?: string[];
     };
+    facetOptions?: {
+        freezeFacetOrder: boolean;
+    } | undefined;
+    sortCriteria: string | undefined;
+    dictionaryFieldContext?: import("../dictionary-field-context/dictionary-field-context-state.js").DictionaryFieldContextPayload | undefined;
+    excerptLength?: number | undefined;
+    filterField?: string | undefined;
+    childField?: string | undefined;
+    parentField?: string | undefined;
+    filterFieldRange?: number | undefined;
+    actionsHistory: import("../../api/analytics/coveo.analytics/history-store.js").HistoryElement[];
+    referrer: string;
+    debug?: boolean | undefined;
     tab: string;
+    locale: string;
+    timezone: string;
     numberOfResults?: number | undefined;
     firstResult?: number | undefined;
     queryCorrection?: {
@@ -60,6 +75,7 @@ export declare const constructAnswerAPIQueryParams: (state: StreamAnswerAPIState
         };
     };
     context?: import("../context/context-state.js").ContextPayload | undefined;
+    enableQuerySyntax?: boolean | undefined;
     lq?: string | undefined;
     dq?: string | undefined;
     cq?: string | undefined;

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

@@ -4,7 +4,7 @@ import type { InsightQueryRequest } from '../../api/service/insight/query/query-
 import type { CategoryFacetSection, ConfigurationSection, ContextSection, DateFacetSection, DidYouMeanSection, FacetSection, FieldsSection, FoldingSection, InsightCaseContextSection, InsightConfigurationSection, NumericFacetSection, PaginationSection, QuerySection, QuerySetSection, QuerySuggestionSection, SearchSection, SortSection, TabSection } from '../../state/state-sections.js';
 import type { InsightAction as LegacyInsightAction } from '../analytics/analytics-utils.js';
 import type { FetchQuerySuggestionsActionCreatorPayload, FetchQuerySuggestionsThunkReturn } from '../query-suggest/query-suggest-actions.js';
-import { type ExecuteSearchThunkReturn, type SearchAction } from '../search/search-actions.js';
+import type { ExecuteSearchThunkReturn, SearchAction } from '../search/search-actions.js';
 import { type MappedSearchRequest } from '../search/search-mappings.js';
 export type StateNeededByExecuteSearch = ConfigurationSection & InsightConfigurationSection & Partial<InsightCaseContextSection & SearchSection & QuerySection & FacetSection & NumericFacetSection & DateFacetSection & CategoryFacetSection & PaginationSection & TabSection & FieldsSection & DidYouMeanSection & SortSection & FoldingSection & ContextSection>;
 export declare const fetchFromAPI: (client: InsightAPIClient, state: StateNeededByExecuteSearch, { request, mappings }: MappedSearchRequest<InsightQueryRequest>, options?: SearchOptions) => Promise<{

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/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/utils/utils.d.ts

@@ -27,3 +27,6 @@ export declare function createWaitForActionMiddlewareForRecommendation<TAction e
     promise: Promise<TAction>;
     middleware: Middleware;
 };
+export declare function debounce<T extends (...args: unknown[]) => unknown>(func: T, wait: number, options?: {
+    isImmediate?: boolean;
+}): T;