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

package/models/i18n/redux/slice.d.ts

@@ -0,0 +1,198 @@
+import { PayloadAction } from '@reduxjs/toolkit';
+import { I18nAppConfig } from "../../models/config/I18n";
+import { LocaleDictionary, LocaleRoutes, Locales } from "../../models/Locales";
+export type UpdateLanguageActionPayload = {
+    language: string;
+    redirect?: boolean | string;
+    fallbackPath?: string;
+};
+declare const i18nSlice: import("@reduxjs/toolkit").Slice<{
+    currentLanguage: string;
+    dictionary: LocaleDictionary;
+    locales: {
+        [language: string]: any;
+    };
+    routes: LocaleRoutes;
+    primaryLanguage: string;
+    supportedLanguages: string[];
+    resolver: ((language: string) => Promise<LocaleDictionary> | LocaleDictionary) | undefined;
+    error: Error | undefined;
+}, {
+    GET_ENTRY_URI_ERROR(draft: import("@reduxjs/toolkit").WritableDraft<{
+        currentLanguage: string;
+        dictionary: LocaleDictionary;
+        locales: {
+            [language: string]: any;
+        };
+        routes: LocaleRoutes;
+        primaryLanguage: string;
+        supportedLanguages: string[];
+        resolver: ((language: string) => Promise<LocaleDictionary> | LocaleDictionary) | undefined;
+        error: Error | undefined;
+    }>, { payload }: PayloadAction<Error>): void;
+    INIT_LOCALES(draft: import("@reduxjs/toolkit").WritableDraft<{
+        currentLanguage: string;
+        dictionary: LocaleDictionary;
+        locales: {
+            [language: string]: any;
+        };
+        routes: LocaleRoutes;
+        primaryLanguage: string;
+        supportedLanguages: string[];
+        resolver: ((language: string) => Promise<LocaleDictionary> | LocaleDictionary) | undefined;
+        error: Error | undefined;
+    }>, { payload, }: PayloadAction<{
+        locales: Locales;
+        routes: LocaleRoutes;
+    } & I18nAppConfig>): void;
+    SET_LANGUAGE(draft: import("@reduxjs/toolkit").WritableDraft<{
+        currentLanguage: string;
+        dictionary: LocaleDictionary;
+        locales: {
+            [language: string]: any;
+        };
+        routes: LocaleRoutes;
+        primaryLanguage: string;
+        supportedLanguages: string[];
+        resolver: ((language: string) => Promise<LocaleDictionary> | LocaleDictionary) | undefined;
+        error: Error | undefined;
+    }>, { payload, }: PayloadAction<{
+        language: string;
+        dictionary: LocaleDictionary;
+        redirect?: string;
+    }>): void;
+    SET_LOCALES(draft: import("@reduxjs/toolkit").WritableDraft<{
+        currentLanguage: string;
+        dictionary: LocaleDictionary;
+        locales: {
+            [language: string]: any;
+        };
+        routes: LocaleRoutes;
+        primaryLanguage: string;
+        supportedLanguages: string[];
+        resolver: ((language: string) => Promise<LocaleDictionary> | LocaleDictionary) | undefined;
+        error: Error | undefined;
+    }>, { payload, }: PayloadAction<{
+        locales: Locales;
+    } & I18nAppConfig>): void;
+    /** UPDATE_LANGUAGE action triggers updateLanguage saga and ends with SET_LANGUAGE */
+    UPDATE_LANGUAGE(_draft: import("@reduxjs/toolkit").WritableDraft<{
+        currentLanguage: string;
+        dictionary: LocaleDictionary;
+        locales: {
+            [language: string]: any;
+        };
+        routes: LocaleRoutes;
+        primaryLanguage: string;
+        supportedLanguages: string[];
+        resolver: ((language: string) => Promise<LocaleDictionary> | LocaleDictionary) | undefined;
+        error: Error | undefined;
+    }>, _: PayloadAction<UpdateLanguageActionPayload>): void;
+}, "i18n", "i18n", import("@reduxjs/toolkit").SliceSelectors<{
+    currentLanguage: string;
+    dictionary: LocaleDictionary;
+    locales: {
+        [language: string]: any;
+    };
+    routes: LocaleRoutes;
+    primaryLanguage: string;
+    supportedLanguages: string[];
+    resolver: ((language: string) => Promise<LocaleDictionary> | LocaleDictionary) | undefined;
+    error: Error | undefined;
+}>>;
+export declare const actions: import("@reduxjs/toolkit").CaseReducerActions<{
+    GET_ENTRY_URI_ERROR(draft: import("@reduxjs/toolkit").WritableDraft<{
+        currentLanguage: string;
+        dictionary: LocaleDictionary;
+        locales: {
+            [language: string]: any;
+        };
+        routes: LocaleRoutes;
+        primaryLanguage: string;
+        supportedLanguages: string[];
+        resolver: ((language: string) => Promise<LocaleDictionary> | LocaleDictionary) | undefined;
+        error: Error | undefined;
+    }>, { payload }: PayloadAction<Error>): void;
+    INIT_LOCALES(draft: import("@reduxjs/toolkit").WritableDraft<{
+        currentLanguage: string;
+        dictionary: LocaleDictionary;
+        locales: {
+            [language: string]: any;
+        };
+        routes: LocaleRoutes;
+        primaryLanguage: string;
+        supportedLanguages: string[];
+        resolver: ((language: string) => Promise<LocaleDictionary> | LocaleDictionary) | undefined;
+        error: Error | undefined;
+    }>, { payload, }: PayloadAction<{
+        locales: Locales;
+        routes: LocaleRoutes;
+    } & I18nAppConfig>): void;
+    SET_LANGUAGE(draft: import("@reduxjs/toolkit").WritableDraft<{
+        currentLanguage: string;
+        dictionary: LocaleDictionary;
+        locales: {
+            [language: string]: any;
+        };
+        routes: LocaleRoutes;
+        primaryLanguage: string;
+        supportedLanguages: string[];
+        resolver: ((language: string) => Promise<LocaleDictionary> | LocaleDictionary) | undefined;
+        error: Error | undefined;
+    }>, { payload, }: PayloadAction<{
+        language: string;
+        dictionary: LocaleDictionary;
+        redirect?: string;
+    }>): void;
+    SET_LOCALES(draft: import("@reduxjs/toolkit").WritableDraft<{
+        currentLanguage: string;
+        dictionary: LocaleDictionary;
+        locales: {
+            [language: string]: any;
+        };
+        routes: LocaleRoutes;
+        primaryLanguage: string;
+        supportedLanguages: string[];
+        resolver: ((language: string) => Promise<LocaleDictionary> | LocaleDictionary) | undefined;
+        error: Error | undefined;
+    }>, { payload, }: PayloadAction<{
+        locales: Locales;
+    } & I18nAppConfig>): void;
+    /** UPDATE_LANGUAGE action triggers updateLanguage saga and ends with SET_LANGUAGE */
+    UPDATE_LANGUAGE(_draft: import("@reduxjs/toolkit").WritableDraft<{
+        currentLanguage: string;
+        dictionary: LocaleDictionary;
+        locales: {
+            [language: string]: any;
+        };
+        routes: LocaleRoutes;
+        primaryLanguage: string;
+        supportedLanguages: string[];
+        resolver: ((language: string) => Promise<LocaleDictionary> | LocaleDictionary) | undefined;
+        error: Error | undefined;
+    }>, _: PayloadAction<UpdateLanguageActionPayload>): void;
+}, "i18n">, reducer: import("../../../node_modules/redux").Reducer<{
+    currentLanguage: string;
+    dictionary: LocaleDictionary;
+    locales: {
+        [language: string]: any;
+    };
+    routes: LocaleRoutes;
+    primaryLanguage: string;
+    supportedLanguages: string[];
+    resolver: ((language: string) => Promise<LocaleDictionary> | LocaleDictionary) | undefined;
+    error: Error | undefined;
+}>, getInitialState: () => {
+    currentLanguage: string;
+    dictionary: LocaleDictionary;
+    locales: {
+        [language: string]: any;
+    };
+    routes: LocaleRoutes;
+    primaryLanguage: string;
+    supportedLanguages: string[];
+    resolver: ((language: string) => Promise<LocaleDictionary> | LocaleDictionary) | undefined;
+    error: Error | undefined;
+};
+export declare const updateLanguage: import("@reduxjs/toolkit").ActionCreatorWithPayload<UpdateLanguageActionPayload, "i18n/UPDATE_LANGUAGE">;
+export default i18nSlice;

package/models/i18n/routes.d.ts

@@ -0,0 +1,8 @@
+import type { AppRoutes } from "../models";
+export declare const deparameterise: (path: string) => string;
+/** Create static routes for routes with specified locales */
+export declare const createLocaleRoutes: (routes: AppRoutes) => {
+    [originalPath: string]: {
+        [locale: string]: string;
+    };
+};

package/models/i18n/useI18n.hook.d.ts

@@ -0,0 +1,20 @@
+import { UpdateLanguageActionPayload } from './redux/slice';
+import { LocaleDictionary } from "../models/Locales";
+type FlattenObjectKeys<T extends Record<string, unknown>, Key = keyof T> = string extends Key ? string : Key extends string ? T[Key] extends Record<string, unknown> ? `${Key}.${FlattenObjectKeys<T[Key]>}` : `${Key}` : never;
+export declare const useI18n: <Dictionary extends LocaleDictionary = LocaleDictionary>() => {
+    /** The language that is currently active */
+    currentLanguage: string;
+    /** The dictionary loaded for the current language / locale */
+    dictionary: Dictionary;
+    /** The locales from the redux store */
+    locales: {
+        [language: string]: any;
+    };
+    /** Localised routes (paths) from the redux store */
+    routes: import("../models/Locales").LocaleRoutes;
+    /** A function to translate keys into localized strings supporting nested keys supplied with dot notation */
+    translate: (key: FlattenObjectKeys<Dictionary>, defaultValue?: string) => string;
+    /** A function that dispatches a redux action to update the current language */
+    updateLanguage: (language: string, { fallbackPath, redirect, }?: Omit<UpdateLanguageActionPayload, "language">) => void;
+};
+export {};

package/models/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./models";
 export { default as linkDepthApi } from "./server/features/linkdepth-api/api";
+export { subsiteDebugMiddleware as DO_NOT_COMMIT_subsiteDebugMiddleware } from "./server/middleware/subsiteDebug";
 import internalServer from "./server/internalServer";
 export { default as ReactApp } from "./app/App";
 export default internalServer;

package/models/models/AppState.d.ts

@@ -1,8 +1,10 @@
 import { VersionStatus } from 'contensis-core-api';
 import { Entry, Node } from 'contensis-delivery-api';
 import { Group, User } from 'contensis-management-api';
+import { getInitialState } from "../i18n/redux/slice";
 import { StaticRoute, MatchedRoute } from "./";
 export type AppState = {
+    i18n: ReturnType<typeof getInitialState>;
     navigation: {
         root: Node | null;
         isError: boolean;

package/models/models/ContentTypeMapping.d.ts

@@ -4,6 +4,7 @@ import { ReduxInjector } from './ReduxInjector';
 import { RouteComponent } from './RouteComponent';
 import { RouteComponentProps } from './RouteComponentProps';
 import { RequireLogin } from './RequireLogin';
+import { SearchRouteOptions } from "../search/models/SearchActions";
 export type ContentTypeMapping = {
     /** The unique identifier for the content type to map. */
     contentTypeID: string;
@@ -14,7 +15,7 @@ export type ContentTypeMapping = {
     /**
      * Optional entry mapper to transform entry data before passing it to the component.
      */
-    entryMapper?: EntryMapper;
+    entryMapper?: EntryMapper<any, any>;
     /**
      * An array of field IDs used to restrict the fields returned for an entry.
      */
@@ -86,4 +87,8 @@ export type ContentTypeMapping = {
      * Specifies whether login is required to access the content for this type.
      */
     requireLogin?: RequireLogin;
+    /**
+     * Triggers the loading of relevant search assets
+     */
+    searchOptions?: SearchRouteOptions;
 };

package/models/models/EntryMapper.d.ts

@@ -1,3 +1,4 @@
+import { Entry } from 'contensis-delivery-api';
 import { AppState } from './AppState';
 import { RouteNode } from './RouteNode';
-export type EntryMapper = (<MappedProps>(node: RouteNode, state?: AppState) => MappedProps | unknown) | (<MappedProps>(node: RouteNode, state?: AppState) => Promise<MappedProps | unknown>);
+export type EntryMapper<MappedProps = any, RouteEntryType extends Entry = Entry> = (node: RouteNode<RouteEntryType>, state: AppState) => MappedProps | Promise<MappedProps>;

package/models/models/Locales.d.ts

@@ -0,0 +1,11 @@
+export type Locales = {
+    [language: string]: any;
+};
+export type LocaleRoutes = {
+    [originalPath: string]: {
+        [locale: string]: string;
+    };
+};
+export type LocaleDictionary = {
+    [key: string]: any;
+};

package/models/models/MatchedRoute.d.ts

@@ -1,4 +1,8 @@
 import type { RouteObject, RouteMatch } from 'react-router';
-export type MatchedRoute<ParamKey extends string = string, TRouteObject extends RouteObject = RouteObject> = Omit<RouteMatch<ParamKey>, 'route'> & {
+type RouteObjectAllowingExtraProps = RouteObject & {
+    [propName: string]: any;
+};
+export type MatchedRoute<ParamKey extends string = string, TRouteObject extends RouteObjectAllowingExtraProps = RouteObjectAllowingExtraProps> = Omit<RouteMatch<ParamKey>, 'route'> & {
     route: TRouteObject;
 };
+export {};

package/models/models/RouteComponent.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import { LoadableComponent } from '@loadable/component';
 import { RouteComponentProps } from './RouteComponentProps';
 export type RouteComponent<Props> = LoadableComponent<RouteComponentProps> | React.ComponentType<Props>;

package/models/models/RouteNode.d.ts

@@ -1,5 +1,7 @@
-import { Node } from 'contensis-delivery-api';
-export type RouteNode = Node & {
+import { Entry, Node } from 'contensis-delivery-api';
+export type RouteNode<T extends Entry = Entry> = Node<T> & {
     ancestors: Node[];
     children: Node[];
+    siblings: Node[];
+    entry: T;
 };

package/models/models/SSRContext.d.ts

@@ -1,12 +1,12 @@
 import { Request, Response } from 'express';
 import { Dispatch } from "../../node_modules/redux";
 import { CookieHelper } from "../user/util/CookieHelper.class";
-import { cachedSearchWithCookies } from "../util";
+import { CachedSearch } from "../util/CachedDeliveryApi";
 export type SSRContext = {
     /** SSR only */
     accessMethod?: SSRAccessMethod;
     /** Available in both SSR and client side */
-    api: ReturnType<typeof cachedSearchWithCookies>;
+    api: CachedSearch;
     /** Available in both SSR and client side */
     cookies: CookieHelper;
     /** Available in both SSR and client side */
@@ -15,8 +15,8 @@ export type SSRContext = {
     request?: Request;
     /** SSR only */
     response?: Response;
-    /** SSR only */
-    ssrAssets?: SSRAssets;
+    /** Available in both SSR and client side */
+    subsitePath?: string;
 };
 export type SSRAccessMethod = {
     DYNAMIC: boolean;

package/models/models/StaticRoute.d.ts

@@ -5,6 +5,7 @@ import { EntryMapper } from './EntryMapper';
 import { ReduxInjector } from './ReduxInjector';
 import { RequireLogin } from './RequireLogin';
 import type { RouteObject } from 'react-router';
+import { SearchRouteOptions } from "../search/models/SearchActions";
 export type StaticRoute = Omit<RouteObject, 'children'> & {
     index?: false | undefined;
     children?: StaticRoute[];
@@ -44,7 +45,7 @@ export type StaticRoute = Omit<RouteObject, 'children'> & {
         /**
          * Optional entry mapper to transform entry data before passing it to the component.
          */
-        entryMapper?: EntryMapper;
+        entryMapper?: EntryMapper<any, any>;
     };
     /** The depth of descendants to include for the node. */
     fetchNodeLevel?: number;
@@ -56,6 +57,16 @@ export type StaticRoute = Omit<RouteObject, 'children'> & {
      * Specifies whether login is required to access the content for this type.
      */
     requireLogin?: RequireLogin;
+    /**
+     * Triggers the loading of the relevant search assets
+     */
+    searchOptions?: SearchRouteOptions;
     ssr?: boolean;
     ssrOnly?: boolean;
+    /** Specify localised paths for different language codes, e.g. { 'en-GB': '/path', 'fr-FR': '/chemin' } */
+    i18n?: {
+        [languageCode: string]: string;
+    };
+    /** The language code for this route, e.g. 'en-GB' */
+    language?: string;
 };

package/models/models/WithEvents.d.ts

@@ -1,10 +1,15 @@
 import { FieldLinkDepths } from 'contensis-core-api';
 import { Entry } from 'contensis-delivery-api';
+import { ContentTypeMapping } from './ContentTypeMapping';
 import { GetRouteActionArgs } from './GetRouteActionArgs';
 import { RequireLogin } from './RequireLogin';
+import { SearchParams, SearchRouteOptions } from "../search/models/SearchActions";
 export type OnRouteLoadArgs = Omit<GetRouteActionArgs, 'withEvents'>;
 export type OnRouteLoadedArgs = OnRouteLoadArgs & {
+    contentTypeRoute?: ContentTypeMapping;
     entry?: Entry | any;
+    params: SearchParams;
+    searchOptions?: SearchRouteOptions;
 };
 /**
  * Configuration options to customize the app state during route changes.
@@ -50,6 +55,9 @@ export type RouteLoadOptions = {
     refetchNode?: true;
 };
 export type RouteLoadedOptions = {
+    searchOptions?: SearchRouteOptions & {
+        onPaths?: string[];
+    };
     requireLogin?: RequireLogin;
 };
 export type WithEvents = {

package/models/models/config/AppConfig.d.ts

@@ -1,7 +1,9 @@
 import { AppRoutes } from '../AppRouteProps';
 import { WithEvents } from '../WithEvents';
+import { I18nAppConfig } from './I18n';
 import { StateType } from './StateType';
 export type AppConfig = {
+    i18n?: I18nAppConfig;
     /** @deprecated Immutable.js library is deprecated and may be removed in future versions. A plain js (and immutable) state is provided by immer package by default */
     stateType?: StateType;
     routes: AppRoutes;

package/models/models/config/I18n.d.ts

@@ -0,0 +1,38 @@
+import { LocaleDictionary, Locales } from '../Locales';
+export type I18nAppConfig<L extends Locales = Locales> = {
+    /** The primary language code for the application */
+    primaryLanguage: string;
+    /** Provide the supported language codes using the same casing convention as Contensis
+     * ```ts
+     *   supportedLanguages: ['cy', 'en-GB', 'fr-FR', 'de-DE']
+     * ```
+     *  Use an empty array to fetch supported languages from the Contensis Project
+     * ```ts
+     *   supportedLanguages: []
+     * ``` */
+    supportedLanguages: string[];
+    /** Supply static locales if not using the resolver
+     *
+     * ```ts
+     *   locales: {
+     *     'en-GB': { title: 'Hello World' },
+     *     'fr-FR': { title: 'Bonjour le monde' },
+     *   }
+     * ```
+     */
+    locales?: L;
+    /** Handle dynamic import of locale dictionaries
+     *
+     * ```ts
+     *   // Example: Each language is in its own file in `~/locales/`,
+     *   // is named using the language code e.g. `en-GB.ts`, `fr-FR.ts`
+     *   // and has a default export
+     *   resolver: (language: string) =>
+     *     import(
+     *       // webpackChunkName: "locale.[request]"
+     *       `~/locales/${language}`
+     *     ).then(({ default: dictionary }) => dictionary)
+     * ```
+     */
+    resolver?: (language: string) => Promise<LocaleDictionary> | LocaleDictionary;
+};

package/models/models/config/ServerConfig.d.ts

@@ -9,6 +9,17 @@ export type ServerConfig = AppConfig & {
     reverseProxyPaths?: string[];
     packagejson: any;
     proxyDeliveryApi?: boolean;
+    /**
+     * `renderToString: true` is recommended for deployments with very
+     * high concurrency while running with limited memory (e.g. <512MB).
+     *
+     * Defaults to `false` to take advantage of streaming mode in React 18,
+     * which offers improved TTFB and overall performance in typical scenarios,
+     * but may lead to increased memory usage under high concurrency due to
+     * the need for a synchronous pre-render to collect Helmet metadata.
+     *
+     * This nuance will likely be removed in the React 19 migration.
+     */
     renderToString?: boolean;
     scripts?: {
         attributes?: {
@@ -17,7 +28,10 @@ export type ServerConfig = AppConfig & {
         startup?: string;
     };
     staticFolderPath?: string;
+    /** The default static route path */
     staticRoutePath?: string;
+    /** Additional static route paths */
+    staticRoutePaths?: string[];
     stats?: string;
     templates: {
         html: string;

package/models/redux/index.d.ts

@@ -1,6 +1,7 @@
 export { action, getJS, getImmutableOrJS as getIn } from './util';
 export { reduxStore as store } from './store/store';
-export { convertSagaArray, injectRedux, injectReducer, injectSaga, useInjectRedux, } from './store/injectors';
+export { injectReducer, injectSaga } from './store/injectors/inject';
+export { injectRedux, useInjectRedux } from './store/injectors/index';
 export declare const navigation: {
     types: typeof import("./types/navigation");
     actions: typeof import("./actions/navigation");

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

@@ -1 +1,3 @@
-export default function _default(featureSagas?: any[]): () => Generator<import("redux-saga/effects").AllEffect<any>, void, unknown>;
+import { Effect } from 'redux-saga/effects';
+declare const _default: (featureSagas?: Effect[]) => Effect<any, any>[];
+export default _default;

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

@@ -0,0 +1,13 @@
+export declare function reduxInjectorSaga(injectorFn: () => Promise<{
+    key: string;
+    reducer: any;
+    saga: any;
+}>): Generator<Promise<{
+    key: string;
+    reducer: any;
+    saga: any;
+}>, void, {
+    key: any;
+    reducer: any;
+    saga: any;
+}>;

package/models/redux/store/injectors/index.d.ts

@@ -0,0 +1,26 @@
+import { Reducer } from "../../../../node_modules/redux";
+import { Effect } from 'redux-saga/effects';
+export declare const injectRedux: ({ key, reducer, saga }: {
+    key: string;
+    reducer?: Reducer;
+    saga?: Effect[];
+}, store?: import("../../../../node_modules/redux").Store<import("../../..").AppState, import("../../../../node_modules/redux").Action, unknown> & {
+    runSaga: (sagas: Effect[] | (() => Generator)) => import("redux-saga").Task;
+    close: () => void;
+    initialSagas: Set<any>;
+    injectedReducers: any;
+    injectedSagas: any;
+    createReducer: (injectedReducers?: any) => Reducer<import("../../..").AppState>;
+}) => void;
+export declare const useInjectRedux: ({ key, reducer, saga }: {
+    key: string;
+    reducer?: Reducer;
+    saga?: Effect[];
+}, store?: import("../../../../node_modules/redux").Store<import("../../..").AppState, import("../../../../node_modules/redux").Action, unknown> & {
+    runSaga: (sagas: Effect[] | (() => Generator)) => import("redux-saga").Task;
+    close: () => void;
+    initialSagas: Set<any>;
+    injectedReducers: any;
+    injectedSagas: any;
+    createReducer: (injectedReducers?: any) => Reducer<import("../../..").AppState>;
+}) => void;

package/models/redux/store/injectors/inject.d.ts

@@ -0,0 +1,24 @@
+import { Reducer } from "../../../../node_modules/redux";
+import { Effect } from 'redux-saga/effects';
+export declare const injectReducer: ({ key, reducer }: {
+    key: string;
+    reducer: Reducer;
+}, store?: import("../../../../node_modules/redux").Store<import("../../..").AppState, import("../../../../node_modules/redux").Action, unknown> & {
+    runSaga: (sagas: Effect[] | (() => Generator)) => import("redux-saga").Task;
+    close: () => void;
+    initialSagas: Set<any>;
+    injectedReducers: any;
+    injectedSagas: any;
+    createReducer: (injectedReducers?: any) => Reducer<import("../../..").AppState>;
+}) => void;
+export declare const injectSaga: ({ key, saga }: {
+    key: string;
+    saga: Effect[];
+}, store?: import("../../../../node_modules/redux").Store<import("../../..").AppState, import("../../../../node_modules/redux").Action, unknown> & {
+    runSaga: (sagas: Effect[] | (() => Generator)) => import("redux-saga").Task;
+    close: () => void;
+    initialSagas: Set<any>;
+    injectedReducers: any;
+    injectedSagas: any;
+    createReducer: (injectedReducers?: any) => Reducer<import("../../..").AppState>;
+}) => void;

package/models/redux/store/injectors/util.d.ts

@@ -0,0 +1,2 @@
+import { Effect } from 'redux-saga/effects';
+export declare const wrapSagasInGenerator: (sagas: Effect[] | (() => Generator)) => () => Generator;

package/models/redux/store/store.d.ts

@@ -1,12 +1,21 @@
-import { Action, Store } from "../../../node_modules/redux";
-import createSagaMiddleware from 'redux-saga';
-import { AppState, StateType } from "../../models";
 import { History, MemoryHistory } from 'history';
+import { Action, Store, Reducer } from "../../../node_modules/redux";
+import { Task } from 'redux-saga';
+import { Effect } from 'redux-saga/effects';
+import { AppState, StateType } from "../../models";
 type ReduxAppStore = Store<AppState, Action>;
+type PatchedRunSaga = (sagas: Effect[] | (() => Generator)) => Task;
 type ReduxSagaAppStore = ReduxAppStore & {
-    runSaga: ReturnType<typeof createSagaMiddleware>['run'];
+    runSaga: PatchedRunSaga;
     close: () => void;
+    initialSagas: Set<any>;
+    injectedReducers: any;
+    injectedSagas: any;
+    createReducer: (injectedReducers?: any) => Reducer<AppState>;
 };
+/** A no-op reducer to serve for server-rendered reducers
+ * that are re-injected client-side */
+export declare const stubReducer: (state?: null) => null;
 export declare let reduxStore: ReduxSagaAppStore;
 declare const _default: (featureReducers: any, initialState: AppState, history: History | MemoryHistory, stateType: StateType) => Promise<ReduxSagaAppStore>;
 export default _default;

package/models/redux/util.d.ts

@@ -1,3 +1,3 @@
 export declare const action: (type: string, payload?: any) => any;
 export declare const getJS: <S extends Record<string, unknown>, T extends keyof S>(state: S, stateKey: T) => S[T];
-export 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 getImmutableOrJS: <S extends Record<string, unknown>, T extends keyof S | any>(state: S, stateKey: T | T[], fallbackValue?: any, returnType?: "immutable" | "js") => any;

package/models/routing/components/RouteLoader.d.ts

@@ -1,4 +1,4 @@
-/// <reference types="react" />
-import { AppRootProps, RouteLoaderProps } from "../../models";
-declare const _default: (props: AppRootProps & RouteLoaderProps) => JSX.Element;
+import React from 'react';
+import type { AppRootProps, RouteLoaderProps } from "../../models";
+declare const _default: (props: AppRootProps & RouteLoaderProps) => React.JSX.Element;
 export default _default;

package/models/routing/httpContext.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 export type HttpContextValues = {
     statusCode?: number;
     url?: string;

package/models/routing/index.d.ts

@@ -5,3 +5,4 @@ export { useHttpContext } from './httpContext';
 export { Redirect } from './components/Redirect';
 export { Status } from './components/Status';
 export { default as RouteLoader } from './components/RouteLoader';
+export { routeParams } from '../search/search/util';

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

@@ -1,7 +1,7 @@
 import { useLocation } from 'react-router-dom';
 import { Entry } from 'contensis-delivery-api/lib/models';
 import { AppRoutes, MatchedRoute, StaticRoute, SSRContext, WithEvents } from "../../models";
-export declare const setNavigationPath: (path: string, location: ReturnType<typeof useLocation>, staticRoute: MatchedRoute<string, StaticRoute> | undefined, withEvents: WithEvents, statePath: string, routes: AppRoutes, ssr: SSRContext) => any;
+export declare const setNavigationPath: (path: string, contentPath: string, location: ReturnType<typeof useLocation>, staticRoute: MatchedRoute<string, StaticRoute> | undefined, withEvents: WithEvents, statePath: string, routes: AppRoutes, ssr: SSRContext) => any;
 export declare const setCurrentProject: (project: string, allowedGroups: any, hostname: string) => any;
 export declare const setRoute: (path: string, state?: any) => any;
 export declare const setRouteEntry: (entry: Entry) => any;