@zengenti/contensis-react-base 4.0.0-beta.8 → 4.0.0

package/models/routing/redux/invokeSearch.d.ts

@@ -0,0 +1,22 @@
+import { OnRouteLoadedArgs, RouteLoadedOptions } from "../../models";
+import { SearchRouteOptions } from "../../search/models/SearchActions";
+/**
+ * Invokes the Search saga if:
+ * - `searchOptions` is present on `staticRoute` or `contentTypeRoute`
+ * - `searchOptions` is provided by the consumer app
+ *   - and path starts with one of `onPaths: ['/search']`
+ *   - or a `facet` or `listingType` is present in provided `searchOptions`
+ *
+ * A `config` is required if we want to inject the redux reducer here, sagas are injected automatically
+ */
+export declare function handleSearchSaga({ location, params, routeSearchOptions, searchOptions, ssr, }: OnRouteLoadedArgs & RouteLoadedOptions & {
+    routeSearchOptions: SearchRouteOptions;
+}): Generator<import("redux-saga/effects").CallEffect<void> | Promise<typeof import("../../search")> | import("redux-saga/effects").CallEffect<Generator<Promise<{
+    key: string;
+    reducer: any;
+    saga: any;
+}>, void, {
+    key: any;
+    reducer: any;
+    saga: any;
+}>>, void, typeof import("../../search")>;

package/models/routing/redux/selectors.d.ts

@@ -1,13 +1,15 @@
-import { AppState, StateType } from "../../models";
+import { AppState, MatchedRoute, StateType, StaticRoute } from "../../models";
 export declare const selectRouteEntry: (state: AppState, returnType?: StateType) => any;
 export declare const selectMappedEntry: (state: AppState, returnType?: StateType) => any;
 export declare const selectSurrogateKeys: (state: AppState) => any;
 export declare const selectSsrApiCalls: (state: AppState) => any;
 export declare const selectCurrentHostname: (state: AppState) => any;
+export declare const selectSsrHostname: (state: AppState) => any;
 export declare const selectCurrentTreeID: (state: AppState) => any;
 export declare const selectRouteEntryEntryId: (state: AppState) => any;
 export declare const selectRouteEntryContentTypeId: (state: AppState) => any;
 export declare const selectRouteEntryLanguage: (state: AppState) => any;
+export declare const selectRouteEntryAvailableLanguages: (state: AppState) => string[];
 export declare const selectRouteEntrySlug: (state: AppState) => any;
 export declare const selectRouteEntryID: (state: AppState) => any;
 export declare const selectCanonicalPath: (state: AppState) => any;
@@ -15,16 +17,57 @@ export declare const selectCurrentPath: (state: AppState) => any;
 export declare const selectCurrentLocation: (state: AppState) => any;
 export declare const selectCurrentSearch: (state: AppState) => any;
 export declare const selectCurrentHash: (state: AppState) => any;
-export declare const selectQueryStringAsObject: (state: AppState) => any;
+export declare const selectQueryStringAsObject: ((state: AppState) => any) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: any) => any;
+    memoizedResultFunc: ((resultFuncArgs_0: any) => any) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => any;
+    dependencies: [(state: AppState) => any];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
 export declare const selectCurrentProject: (state: AppState) => any;
 export declare const selectIsNotFound: (state: AppState) => any;
 export declare const selectCurrentAncestors: (state: AppState) => any;
 export declare const selectCurrentSiblings: (state: AppState) => any;
 export declare const selectCurrentNode: (state: AppState, returnType?: StateType) => any;
+export declare const selectCurrentNodeLanguage: (state: AppState) => any;
 export declare const selectCurrentChildren: (state: any) => any;
-export declare const selectBreadcrumb: (state: AppState) => any[];
+export declare const selectBreadcrumb: ((state: AppState, returnType?: StateType | undefined) => any[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: any, resultFuncArgs_1: any) => any[];
+    memoizedResultFunc: ((resultFuncArgs_0: any, resultFuncArgs_1: any) => any[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => any[];
+    dependencies: [(state: AppState) => any, (state: AppState, returnType?: StateType) => any];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
 export declare const selectRouteErrorMessage: (state: AppState) => any;
 export declare const selectRouteIsError: (state: AppState) => any;
 export declare const selectRouteLoading: (state: AppState) => any;
 export declare const selectRouteStatusCode: (state: AppState) => any;
-export declare const selectStaticRoute: (state: AppState) => any;
+export declare const selectStaticRoute: (state: AppState) => MatchedRoute<string, StaticRoute>;

package/models/routing/util/expressions.d.ts

@@ -1,3 +1,3 @@
 import { IExpression } from 'contensis-core-api';
 export declare const fieldExpression: (field: string, value: string | string[], operator?: string, weight?: null) => any[];
-export declare const defaultExpressions: (versionStatus: 'published' | 'latest') => IExpression[];
+export declare const defaultExpressions: (versionStatus: "published" | "latest") => IExpression[];

package/models/routing/util/find-contenttype-mapping.d.ts

@@ -1,2 +1,4 @@
-import { ContentTypeMapping } from "../../models";
+import { ContentTypeMapping, MatchedRoute } from "../../models";
 export declare const findContentTypeMapping: (ContentTypeMappings: ContentTypeMapping[], contentTypeId: string) => ContentTypeMapping | undefined;
+/** Find a searchOptions object in any of the current routes */
+export declare const getSearchOptions: (staticRoute: MatchedRoute, contentTypeRoute: ContentTypeMapping) => any;

package/models/search/containers/withListing.d.ts

@@ -2,6 +2,6 @@ import React from 'react';
 import { Mappers } from '../models/Search';
 declare const withListing: (mappers: Mappers) => <Props extends Record<string, any>>(ListingComponent: React.FC<Props>) => import("react-redux").ConnectedComponent<any, {
     context?: React.Context<import("react-redux").ReactReduxContextValue<any, import("../../../node_modules/redux").UnknownAction> | null> | undefined;
-    store?: import("../../../node_modules/redux").Store<any, import("../../../node_modules/redux").UnknownAction, unknown> | undefined;
+    store?: import("../../../node_modules/redux").Store | undefined;
 }>;
 export default withListing;

package/models/search/containers/withSearch.d.ts

@@ -2,6 +2,6 @@ import React from 'react';
 import { Mappers } from '../models/Search';
 declare const withSearch: (mappers: Mappers) => <Props extends Record<string, any>>(SearchComponent: React.ComponentType<Props>) => import("react-redux").ConnectedComponent<any, {
     context?: React.Context<import("react-redux").ReactReduxContextValue<any, import("../../../node_modules/redux").UnknownAction> | null> | undefined;
-    store?: import("../../../node_modules/redux").Store<any, import("../../../node_modules/redux").UnknownAction, unknown> | undefined;
+    store?: import("../../../node_modules/redux").Store | undefined;
 }>;
 export default withSearch;

package/models/search/models/Queries.d.ts

@@ -1,5 +1,6 @@
 import { FieldLinkDepths, Operators, Query, QueryAggregations, VersionStatus } from 'contensis-core-api';
 import { CustomWhereClause, FeaturedResults, WeightedSearchField } from './Search';
+import { SearchParams } from './SearchActions';
 export type FieldOperators = Exclude<keyof Operators, 'and' | 'or' | 'not'>;
 export type LogicOperators = 'and' | 'or' | 'not';
 export type FilterExpression = {
@@ -32,7 +33,6 @@ export type SearchQueryOptions = {
     weightedSearchFields: WeightedSearchField[];
 };
 export type QueryParams = SearchQueryOptions & {
-    env: string;
     internalPageIndex: number;
     internalPaging: boolean;
     linkDepth: number;
@@ -40,9 +40,7 @@ export type QueryParams = SearchQueryOptions & {
     pagesLoaded: number[];
     prevPageIndex: number;
     projectId: string;
-    selectedFilters: {
-        [key: string]: string;
-    };
+    selectedFilters: SearchParams;
 };
 export type SearchQuery = ({ aggregations, contentTypeIds, customWhere, dynamicOrderBy, excludeIds, featuredResults, fields, filters, fuzzySearch, languages, pageSize, pageIndex, omitDefaultSearchFields, orderBy, searchTerm, versionStatus, webpageTemplates, weightedSearchFields, }: SearchQueryOptions, isFeatured?: boolean) => Query;
-export type FilterQuery = (contentTypeIds: string[], versionStatus: VersionStatus, customWhere?: CustomWhereClause) => Query;
+export type FilterQuery = (contentTypeIds: string[], languages: string[], versionStatus: VersionStatus, customWhere?: CustomWhereClause, pageSize?: number) => Query;

package/models/search/models/Search.d.ts

@@ -4,6 +4,19 @@ import { MappingTemplate } from 'jsonpath-mapper';
 import { Context } from './Enums';
 import { FieldOperators, LogicOperators } from './Queries';
 import { AppState } from './SearchState';
+export type FacetComposition = {
+    /** Display title */
+    title?: string;
+    /** An array of facet keys to include in this composition */
+    facets?: string[];
+};
+export type ListingComposition = {
+    /** Display title */
+    title?: string;
+    /** An array of listing keys to include in this composition */
+    listings?: string[];
+};
+export type Composition = FacetComposition | ListingComposition;
 export type Tab = {
     /** The facet to render as default */
     defaultFacet?: string;
@@ -19,13 +32,6 @@ export type CustomApi = {
     uri: string;
 };
 export type Listing = {
-    /** Display title */
-    title?: string;
-    /** Experimental: use a custom API to retrieve search results */
-    customApi?: CustomApi;
-} | {
-    /** Experimental: override the rootUrl of the Delivery API client  */
-    env?: string;
     /** An object with a key for each filter that is required in this facet */
     filters?: SearchFilters;
     /** Use this to target the search to a project other than the default configured */
@@ -34,6 +40,12 @@ export type Listing = {
     queryParams: SearchQueryParams;
     /** Display title */
     title?: string;
+    /** Experimental: use a custom API to retrieve search results */
+    customApi?: CustomApi;
+    /** Internationalisation config */
+    i18n?: {
+        [language: string]: string;
+    };
 };
 export type SearchFacet = {
     /** The first facet to be shown if no facet is supplied via a route parameter [default false] */
@@ -47,13 +59,17 @@ export type SearchFilters = {
     [key: string]: SearchFilter;
 };
 export type SearchFilter = {
+    /** Populate items using aggregations, `true` will enable or supply name(s) of other field aggregations to populate the items with */
+    aggregations?: boolean | string | string[];
     /** The content type id we will dynamically load entries from and load into state under the items[] */
     contentTypeId?: string | string[];
     /** An array of CustomWhereClause to include in the search query when dynamically loading entries via the contentTypeId key */
     customWhere?: CustomWhereClause;
+    /** Max number of items returned when providing `contentTypeId`, default is 100  */
+    pageSize?: number;
     /** Use this to set a specific value to render for the initial / unselected option in this filter */
     defaultValue?: string;
-    /** The content type field we will apply the filter key to, to filter the list of returned results. */
+    /** The content type field id(s) we will apply selected filter keys to, so we can filter the list of returned results. */
     fieldId: string | string[];
     /** The Delivery API search operator we will use to filter the list of returned results. */
     fieldOperator?: FieldOperators;
@@ -67,10 +83,18 @@ export type SearchFilter = {
     isSingleSelect?: boolean;
     /** Supply an empty array or a hardcoded list of FilterItem depending on the type of filter we require */
     items: FilterItem[];
-    /** Set to false to not include this filter in filters prop */
+    /** Setting `false` will change the filter behaviour:
+     *
+     * a) to be excluded from the `filters` prop
+     *
+     * b) to not include selected items in the querystring on next navigate */
     renderable?: boolean;
     /** The title to render next to the filter */
     title: string;
+    /** Internationalisation config */
+    i18n?: {
+        [language: string]: string;
+    };
 };
 export type FilterItem = {
     /** Whether the filter is in a selected state */
@@ -113,6 +137,8 @@ export type SearchQueryParams = {
     includeInSearch?: string[];
     /** Whether or not to load all results with the first page and handle all pagination yourself */
     internalPaging?: boolean;
+    /** Search within specific languages */
+    languages?: string[];
     /** The linkDepth to apply to the facet search (defaults to 0) */
     linkDepth?: number;
     /** Alters the pagination style to retain previously loaded pages of results after loading next pages */
@@ -161,7 +187,7 @@ export type WeightedSearchField = {
  */
 export type SearchConfig = {
     /** An object with a key for each facet that is required for the search */
-    facets: {
+    facets?: {
         [key: string]: SearchFacet;
     };
     /** An object with a key for each independent listing that is required for the site */
@@ -172,8 +198,12 @@ export type SearchConfig = {
     minilist?: {
         [key: string]: Listing;
     };
-    /** An Array of Tabs */
-    tabs: Tab[];
+    /** An Array of Tabs to partition search facets */
+    tabs?: Tab[];
+    /** An object with a key for each composition that is required for the site */
+    compositions?: {
+        [key: string]: Composition;
+    };
 };
 export type ConfigTypes = {
     [key: string]: SearchFacet;
@@ -183,7 +213,7 @@ export type ConfigTypes = {
 /**
  * Type your mapper for mapping API responses (entries) into usable props for your components to render
  */
-export type SearchResultsMapper<Target = any, Source = Entry> = (entries: Source[], facet?: string, context?: Context, state?: AppState) => Target[];
+export type SearchResultsMapper<Target = any, Source = Entry> = (entries: Source[], facet?: string, context?: keyof typeof Context, state?: AppState) => Target[];
 /**
  * Type your custom filter item mapping function with this to ensure correctly typed FilterItems are returned to work with search functions
  */

package/models/search/models/SearchActions.d.ts

@@ -1,10 +1,20 @@
 import { PagedList } from 'contensis-core-api';
 import { Entry, TaxonomyNode } from 'contensis-delivery-api/lib/models';
 import { Context } from '../models/Enums';
-import { SearchFacet, Listing, Mappers } from '../models/Search';
-import { AppState, Facet } from './SearchState';
+import { SearchFacet, Listing, Mappers, SearchConfig } from '../models/Search';
+import { AppState, Facet, Filter } from './SearchState';
 import { QueryParams } from './Queries';
 import { TimedSearchResponse } from './SearchUtil';
+import { SSRContext } from "../../models";
+/**
+ * Parameters for the current search
+ * usually provided by route, path or query parameters or
+ * can be overridden manually to manipulate the search to
+ * drive certain conditions when required
+ */
+export type SearchParams = {
+    [key: string]: string;
+};
 type Action = {
     type: string;
 };
@@ -24,33 +34,49 @@ export type TriggerSearchParams = {
     facet: string;
     mapper?: Mappers['results'];
     mappers?: Mappers;
-    params?: {
-        [key: string]: string;
-    };
+    params?: SearchParams;
+    ssr?: SSRContext;
 };
 export type TriggerSearchAction = Action & TriggerSearchParams;
 export type TriggerSearchActionCreator = (p: TriggerSearchParams) => TriggerSearchAction;
 type InitListingParams = {
-    context: Context;
+    context: keyof typeof Context;
     debug?: DebugFlags;
     defaultLang?: string;
+    languages?: string[];
+    /**
+     * Triggers the loading of the search config facet
+     */
     facet: string;
+    /**
+     * Triggers the loading of the search config listing
+     */
     listingType?: string;
+    /**
+     * Triggers the loading of the search config composition
+     */
+    composition?: string;
     mapper?: Mappers['results'];
     mappers?: Mappers;
-    params: {
-        [key: string]: string;
-    };
+    params: SearchParams;
     preload?: boolean;
+    ssr?: SSRContext;
 };
 export type InitListingAction = Action & InitListingParams & {
-    ssr?: boolean;
-};
-export type SetRouteFiltersOptions = Partial<InitListingAction>;
+    isSSR?: boolean;
+};
+export type SetRouteFiltersOptions = Omit<Partial<InitListingAction>, 'type'>;
+export type SearchRouteOptions = Omit<SetRouteFiltersOptions & {
+    /**
+     * The search configuration to use for the search
+     */
+    config?: SearchConfig;
+}, 'ssr' | 'isSSR'>;
 export type InitListingActionCreator = (p: InitListingParams) => InitListingAction;
 export type LoadFiltersSearchResults = Action & {
     error: any;
     facetKey: string;
+    filter: Filter;
     filterKey: string;
     payload: TaxonomyNode | PagedList<Entry>;
     selectedKeys: string[];
@@ -66,6 +92,17 @@ export type SearchResults = {
     result: TimedSearchResponse;
     state: AppState;
 };
+export type LoadFilterAction = {
+    context: Context;
+    facetKey: string;
+    filter: Filter;
+    filterKey: string;
+    languages: string[];
+    mapper: Mappers['filterItems'];
+    projectId: string;
+    selectedKeys: string[];
+    ssr?: SSRContext;
+};
 export type LoadFiltersCompleteAction = Action & {
     error: any;
     facetKey: string;
@@ -85,16 +122,14 @@ export type ExecuteSearchAction = EnsureSearchAction & {
 export type SetSearchEntriesParams = {
     type: string;
     context: Context;
-    defaultLang: string;
+    languages: string[];
     facet: string;
     mappers: Mappers;
     nextFacet: Facet;
     preload: boolean;
     ogState: AppState;
     debug: DebugFlags;
-    params: {
-        [key: string]: string;
-    };
+    params: SearchParams;
 };
 export type SetSearchEntriesAction = Action & SetSearchEntriesParams;
 export type ApplySearchFilterAction = Action & {
@@ -104,8 +139,16 @@ export type ApplySearchFilterAction = Action & {
     scrollToElement?: string;
 };
 export type ApplySearchFilterActionCreator = (filter: string, key: string) => ApplySearchFilterAction;
-export type ClearFiltersAction = Action;
-export type ClearFiltersActionCreator = (filterKey?: string) => ClearFiltersAction;
+export type ClearFiltersAction = Action & {
+    clear?: {
+        term?: boolean;
+        keys?: boolean | string[];
+    };
+};
+export type ClearFiltersActionCreator = (clear?: string | {
+    term?: boolean;
+    keys?: boolean | string[];
+}) => ClearFiltersAction;
 export type UpdateCurrentFacetAction = Action & {
     facet: string;
 };

package/models/search/models/SearchProps.d.ts

@@ -1,7 +1,8 @@
 import { clearFilters, updateCurrentFacet, updateCurrentTab, updatePageIndex, updatePageSize, updateSearchTerm, updateSelectedFilters, updateSortOrder } from '../redux/actions';
 import { SearchFacet, Mappers } from '../models/Search';
-import { DebugFlags } from '../models/SearchActions';
+import { DebugFlags, SearchParams } from '../models/SearchActions';
 import { Facet as StateFacet, Facets, Filters, Paging, SelectedFilters, TabAndFacets } from '../models/SearchState';
+import { getComposition } from '../redux/selectors';
 export interface MinilistProps<SearchResults = any> {
     filters: Filters;
     isLoading: boolean;
@@ -18,12 +19,15 @@ export interface MinilistProps<SearchResults = any> {
 }
 export interface ListingProps<SearchResults = any> {
     clearFilters: typeof clearFilters;
+    composition?: Omit<ReturnType<typeof getComposition>, 'facets'>;
+    currentComposition?: string;
     currentListing: string;
     currentPageIndex: number;
     featured: SearchResults[];
     filters: Filters;
     isLoading: boolean;
     listing: StateFacet;
+    localisedCurrent: string;
     pageIsLoading: boolean;
     paging: Paging;
     results: SearchResults[];
@@ -41,6 +45,8 @@ export interface ListingProps<SearchResults = any> {
 }
 export interface SearchProps<SearchResults = any> {
     clearFilters: typeof clearFilters;
+    composition?: Omit<ReturnType<typeof getComposition>, 'listings'>;
+    currentComposition?: string;
     currentFacet: string;
     currentPageIndex: number;
     currentTabIndex: number;
@@ -55,6 +61,7 @@ export interface SearchProps<SearchResults = any> {
     featured: SearchResults[];
     filters: Filters;
     isLoading: boolean;
+    localisedCurrent: string;
     pageIsLoading: boolean;
     paging: Paging;
     results: SearchResults[];
@@ -79,9 +86,7 @@ export interface UseFacetsProps {
     mappers?: Mappers;
     /** Reserved for future use */
     id?: string;
-    params?: {
-        [key: string]: string;
-    };
+    params?: SearchParams;
 }
 export interface UseListingProps {
     debug?: DebugFlags;
@@ -89,9 +94,7 @@ export interface UseListingProps {
     mappers?: Mappers;
     /** Reserved for future use */
     id?: string;
-    params?: {
-        [key: string]: string;
-    };
+    params?: SearchParams;
 }
 export interface UseMinilistProps {
     id: string;
@@ -101,7 +104,5 @@ export interface UseMinilistProps {
     excludeIds?: string[];
     mapper?: Mappers['results'];
     mappers?: Mappers;
-    params?: {
-        [key: string]: string;
-    };
+    params?: SearchParams;
 }

package/models/search/models/SearchState.d.ts

@@ -1,16 +1,22 @@
 import { PagedSearchList } from 'contensis-core-api';
 import { Context } from './Enums';
 import { CustomWhereClause } from './Search';
-export type AppState = Record<'search', SearchState> & Record<string, any>;
+import { AppState as ReduxState } from "../../models";
+export type AppSearchState = Record<'search', SearchState>;
+export type AppState = AppSearchState & ReduxState;
 export type SearchState = {
     context: keyof typeof Context;
     currentFacet: string;
     currentListing: string;
+    currentComposition: string;
     term: string;
     facets: Facets;
     listings: Facets;
     minilist: Facets;
     tabs: Tab[];
+    compositions: {
+        [key: string]: Composition;
+    };
     config: Record<string, boolean>;
 };
 export type Aggregations = Required<PagedSearchList<unknown>>['aggregations'];
@@ -31,6 +37,9 @@ export type Facet = {
     };
     featuredResults: any[];
     filters: Filters;
+    i18n?: {
+        [language: string]: string;
+    };
     pagingInfo: {
         isLoading: boolean;
         pageCount: number;
@@ -46,13 +55,15 @@ export type Facet = {
     queryParams: {
         contentTypeIds: string[];
         dynamicOrderBy: string[];
-        pageSize: number;
         excludeIds: string[];
         internalPaging: boolean;
+        languages: string[];
         loadMorePaging: boolean;
+        pageSize: number;
         useSearchTerm: boolean;
     };
     results: any[];
+    resultsInfo?: any;
     tabId: number;
     title: string;
 };
@@ -60,15 +71,20 @@ export type Filters = {
     [key: string]: Filter;
 };
 export type Filter = {
+    aggregations?: boolean | string | string[];
     contentTypeId?: string;
     customWhere?: CustomWhereClause;
     defaultValue?: string;
     fieldId?: string | string[];
+    i18n?: {
+        [language: string]: string;
+    };
     isGrouped?: boolean;
     isSingleSelect?: boolean;
     isLoading: boolean;
     isError: boolean;
     items?: FilterItem[];
+    pageSize?: number;
     path?: string;
     renderable?: boolean;
     title?: string;
@@ -106,3 +122,8 @@ export type TabAndFacets = Tab & {
         [key: string]: Facet;
     };
 };
+export type Composition = {
+    title?: string;
+    listings?: string[];
+    facets?: string[];
+};

package/models/search/models/SearchUtil.d.ts

@@ -1,6 +1,6 @@
-import { Entry } from 'contensis-delivery-api/lib/models';
-import { PagedList } from 'contensis-core-api';
+import { Entry } from 'contensis-delivery-api';
+import { PagedSearchList } from 'contensis-core-api';
 export type TimedSearchResponse = {
     duration: number;
-    payload: PagedList<Entry> | any[];
+    payload: PagedSearchList<Entry> | any[];
 };

package/models/search/redux/getIn.d.ts

@@ -1,3 +1,3 @@
-export declare const makeFromJS: (returnType?: 'immutable' | 'js') => any;
-declare const getImmutableOrJS: <S extends Record<string, unknown>, T extends unknown>(state: S, stateKey: T | T[], fallbackValue?: any, returnType?: 'immutable' | 'js') => any;
+export declare const makeFromJS: (returnType?: "immutable" | "js") => any;
+declare const getImmutableOrJS: <S extends Record<string, unknown>, T extends keyof S | any>(state: S, stateKey: T | T[], fallbackValue?: any, returnType?: "immutable" | "js") => any;
 export default getImmutableOrJS;

package/models/search/redux/reducers.d.ts

@@ -1,12 +1,11 @@
-import { SearchConfig } from '../models/Search';
 import { Context } from '../models/Enums';
+import { SearchConfig } from '../models/Search';
+import { SearchParams } from '../models/SearchActions';
 import { SearchState } from '../models/SearchState';
 declare const _default: (config: SearchConfig) => (state?: SearchState | undefined, action: {
     [key: string]: any;
     context: keyof typeof Context;
     facet: string;
-    params: {
-        [key: string]: string;
-    };
+    params: SearchParams;
 }) => SearchState;
 export default _default;

package/models/search/redux/sagas.d.ts

@@ -1,22 +1,21 @@
-import { Entry } from 'contensis-delivery-api/lib/models';
-import { InitListingAction, SetRouteFiltersOptions, TriggerSearchAction, TriggerSearchParams } from '../models/SearchActions';
+import { InitListingAction, SearchParams, SetRouteFiltersOptions, TriggerSearchAction, TriggerSearchParams } from '../models/SearchActions';
 import { Mappers } from '../models/Search';
+import { Context } from '../models/Enums';
 export declare const searchSagas: import("redux-saga/effects").ForkEffect<never>[];
 export declare function setRouteFilters(action: InitListingAction | SetRouteFiltersOptions): Generator<import("redux-saga/effects").SelectEffect | import("redux-saga/effects").PutEffect<InitListingAction> | import("redux-saga/effects").CallEffect<void>, void, any>;
-export declare function doSearch(action: TriggerSearchAction): Generator<import("redux-saga/effects").SelectEffect | import("redux-saga/effects").PutEffect<{
+export declare function doSearch(action: TriggerSearchAction): Generator<import("redux-saga/effects").SelectEffect | import("redux-saga/effects").PutEffect<InitListingAction> | import("redux-saga/effects").CallEffect<void> | import("redux-saga/effects").PutEffect<{
     type: string;
-    config?: import("../models/Search").Listing | import("../models/Search").SearchFacet | undefined;
-    context: string;
-    debug?: import("../models/SearchActions").DebugFlags | undefined;
-    defaultLang?: string | undefined;
-    excludeIds?: string[] | undefined;
+    config?: import("../models/Search").SearchFacet | import("../models/Search").Listing;
+    context: Context | string;
+    debug?: import("../models/SearchActions").DebugFlags;
+    defaultLang?: string;
+    excludeIds?: string[];
     facet: string;
-    mapper?: import("../models/Search").SearchResultsMapper<any, Entry> | undefined;
-    mappers?: Mappers | undefined;
-    params?: {
-        [key: string]: string;
-    } | undefined;
-}> | import("redux-saga/effects").PutEffect<InitListingAction> | import("redux-saga/effects").CallEffect<void>, void, any>;
+    mapper?: Mappers["results"];
+    mappers?: Mappers;
+    params?: SearchParams;
+    ssr?: import("../..").SSRContext;
+}>, void, any>;
 export declare function triggerMinilistSsr(options: TriggerSearchParams): Generator<import("redux-saga/effects").CallEffect<void>, void, unknown>;
 export declare function triggerListingSsr(options: SetRouteFiltersOptions & {
     listingType: string;

package/models/search/redux/schema.d.ts

@@ -49,9 +49,9 @@ export declare const searchTab: {
     label: undefined;
     totalCount: string;
 };
-export declare const filtering: Omit<Filter, "items" | "customWhere"> & {
-    customWhere?: CustomWhereClause[] | undefined;
-    items?: FilterItem[] | undefined;
+export declare const filtering: Omit<Filter, "customWhere" | "items"> & {
+    customWhere?: CustomWhereClause[];
+    items?: FilterItem[];
 };
 export declare const filterItem: FilterItem;
 export declare const initialState: SearchState;