@zengenti/contensis-react-base 4.0.0-beta.2 → 4.0.0-beta.20

package/models/server/util/bundles.d.ts

@@ -1,12 +1,12 @@
 import { ChunkExtractor } from '@loadable/server';
-import { ServerConfig } from "../../config";
+import { ServerConfig } from "../../models";
 export declare const loadableBundleData: ({ stats, templates }: ServerConfig, staticRoutePath: string, build?: string) => {
-    stats?: string | null | undefined;
+    stats?: string | null;
     templates?: {
         templateHTML: string;
         templateHTMLStatic: string;
         templateHTMLFragment: string;
-    } | null | undefined;
+    } | null;
 };
 type LoadableChunkExtractors = {
     legacy?: ChunkExtractor;
@@ -16,29 +16,29 @@ type LoadableChunkExtractors = {
 export declare const loadableChunkExtractors: () => LoadableChunkExtractors;
 export declare const getBundleData: (config: ServerConfig, staticRoutePath: string) => {
     default: {
-        stats?: string | null | undefined;
+        stats?: string | null;
         templates?: {
             templateHTML: string;
             templateHTMLStatic: string;
             templateHTMLFragment: string;
-        } | null | undefined;
+        } | null;
     };
     legacy: {
-        stats?: string | null | undefined;
+        stats?: string | null;
         templates?: {
             templateHTML: string;
             templateHTMLStatic: string;
             templateHTMLFragment: string;
-        } | null | undefined;
+        } | null;
     };
     modern: {
-        stats?: string | null | undefined;
+        stats?: string | null;
         templates?: {
             templateHTML: string;
             templateHTMLStatic: string;
             templateHTMLFragment: string;
-        } | null | undefined;
+        } | null;
     };
 };
-export declare const getBundleTags: (loadableExtractor: LoadableChunkExtractors, scripts: ServerConfig['scripts'], staticRoutePath?: string) => string;
+export declare const getBundleTags: (loadableExtractor: LoadableChunkExtractors, scripts: ServerConfig["scripts"], staticRoutePath?: string) => string;
 export {};

package/models/server/util/headers.d.ts

@@ -1,5 +1,5 @@
 import { Response } from 'express';
-import { AppState } from "../../redux/appstate";
+import { AppState } from "../../models";
 export declare const addStandardHeaders: (state: AppState, response: Response, packagejson: any, groups: {
     globalGroups?: any[];
     allowedGroups?: any[];

package/models/server/util/html.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Add assets to templateHTML in the positions represented
+ * by replacing specific keys wrapped in handlebars depending
+ * on the accessMethod(s) that have been set (or updated)
+ * while processing the request
+ */
+export declare const replaceHtml: ({ bundleTags, html, htmlAttributes, metadata, state, styleTags, title, templateHTML, templateHTMLFragment, templateHTMLStatic, }: {
+    bundleTags?: string | undefined;
+    html?: string | undefined;
+    htmlAttributes?: string | undefined;
+    metadata?: string | undefined;
+    state?: string | undefined;
+    styleTags?: string | undefined;
+    title?: string | undefined;
+    templateHTML?: string | undefined;
+    templateHTMLFragment?: string | undefined;
+    templateHTMLStatic?: string | undefined;
+}, accessMethod: {
+    DYNAMIC: boolean;
+    REDUX: boolean;
+    FRAGMENT: boolean;
+    STATIC: boolean;
+}) => string;

package/models/server/util/jsx.d.ts

@@ -0,0 +1,42 @@
+import { ChunkExtractor } from '@loadable/server';
+import { Request, Response } from 'express';
+import React from 'react';
+import { ServerStyleSheet } from 'styled-components';
+import Cookies from 'universal-cookie';
+import { AppRoutes, SSRAccessMethod, WithEvents } from "../../models";
+import { reduxStore } from "../../redux/store/store";
+import { HttpContextValues } from "../../routing/httpContext";
+/**
+ * Produce the JSX wrapped in the necessary Providers
+ * to render the app in SSR
+ * @param ReactApp the JSX to render
+ * @param { providers, props, ssrAssets }
+ * @returns the final JSX to render decorated with all Provider and App props
+ */
+export declare const ssrJsxProducer: (ReactApp: React.ComponentType<any>, { providers, props, }: {
+    /** Providers enrich the JSX */
+    providers: {
+        loadable: {
+            extractor: ChunkExtractor;
+        };
+        cookies?: Cookies;
+        redux: typeof reduxStore;
+        httpContext: HttpContextValues;
+        router: {
+            url: string;
+        };
+        styledComponents?: {
+            sheet: ServerStyleSheet;
+        };
+        ssrContext: {
+            accessMethod: SSRAccessMethod;
+            request: Request;
+            response: Response;
+        };
+    };
+    /** Props are supplied to the ReactApp */
+    props: {
+        routes: AppRoutes;
+        withEvents: WithEvents;
+    };
+}) => React.JSX.Element;

package/models/server/webApp.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
 import { Express } from 'express';
-import { ServerConfig } from "../config";
+import { ServerConfig } from "../models";
 declare const webApp: (app: Express, ReactApp: React.ComponentType<any>, config: ServerConfig & {
     allowedGroups?: string[];
     globalGroups?: string[];

package/models/user/components/Login.d.ts

@@ -7,4 +7,4 @@ declare const _default: (wrappedComponentProps: {
     logoutUser: any;
 }) => React.JSX.Element;
 export default _default;
-import React from "react";
+import React from 'react';

package/models/user/components/LoginForm.d.ts

@@ -6,11 +6,11 @@ declare function LoginForm({ authenticationError, loading, loginUser }: {
 }): React.JSX.Element;
 declare namespace LoginForm {
     namespace propTypes {
-        const loginException: PropTypes.Requireable<boolean>;
-        const authenticationError: PropTypes.Requireable<boolean>;
-        const loading: PropTypes.Requireable<boolean>;
-        const loginUser: PropTypes.Requireable<(...args: any[]) => any>;
+        let loginException: PropTypes.Requireable<boolean>;
+        let authenticationError: PropTypes.Requireable<boolean>;
+        let loading: PropTypes.Requireable<boolean>;
+        let loginUser: PropTypes.Requireable<(...args: any[]) => any>;
     }
 }
-import React from "react";
-import PropTypes from "prop-types";
+import React from 'react';
+import PropTypes from 'prop-types';

package/models/user/components/LogoutForm.d.ts

@@ -5,9 +5,9 @@ declare function LogoutForm({ logoutUser, user }: {
 }): React.JSX.Element;
 declare namespace LogoutForm {
     namespace propTypes {
-        const logoutUser: PropTypes.Requireable<(...args: any[]) => any>;
-        const user: PropTypes.Requireable<object>;
+        let logoutUser: PropTypes.Requireable<(...args: any[]) => any>;
+        let user: PropTypes.Requireable<object>;
     }
 }
-import React from "react";
-import PropTypes from "prop-types";
+import React from 'react';
+import PropTypes from 'prop-types';

package/models/user/components.styled/Login.styled.d.ts

@@ -1,2 +1,2 @@
 export default LoginStyled;
-declare const LoginStyled: any;
+declare const LoginStyled: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;

package/models/user/components.styled/LoginForm.styled.d.ts

@@ -1,2 +1,2 @@
 export default LoginFormStyled;
-declare const LoginFormStyled: any;
+declare const LoginFormStyled: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;

package/models/user/hocs/withLogin.d.ts

@@ -1,7 +1,7 @@
-export default withLogin;
-declare function withLogin(WrappedComponent: any): {
+import React from 'react';
+declare const withLogin: (WrappedComponent: React.ComponentType) => {
     (): React.JSX.Element;
     displayName: string;
-    WrappedComponent: any;
+    WrappedComponent: React.ComponentType<{}>;
 };
-import React from "react";
+export default withLogin;

package/models/user/hocs/withRegistration.d.ts

@@ -1,6 +1,9 @@
 export default withRegistration;
 declare function withRegistration(WrappedComponent: any): import("react-redux").ConnectedComponent<(wrappedComponentProps: {
     [key: string]: any;
-}) => import("react").JSX.Element, import("react-redux").Omit<{
-    [key: string]: any;
-}, "error" | "isLoading" | "user" | "registerUser" | "isSuccess">>;
+}) => import("react").JSX.Element, {
+    [x: string]: any;
+    [x: number]: any;
+    context?: import("react").Context<import("react-redux").ReactReduxContextValue<any, import("../../../node_modules/redux").UnknownAction> | null> | undefined;
+    store?: import("../../../node_modules/redux").Store | undefined;
+}>;

package/models/user/hooks/useLogin.d.ts

@@ -1,7 +1,6 @@
-export default useLogin;
-declare function useLogin(): {
-    loginUser: (username: any, password: any) => any;
-    logoutUser: (redirectPath: any) => any;
+declare const useLogin: () => {
+    loginUser: (username: string, password: string) => any;
+    logoutUser: (redirectPath?: string) => any;
     errorMessage: any;
     isAuthenticated: any;
     isAuthenticationError: any;
@@ -12,3 +11,4 @@ declare function useLogin(): {
     authenticationErrorMessage: any;
     error: any;
 };
+export default useLogin;

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

@@ -1,6 +1,7 @@
-export function loginUser(username: any, password: any, cookies: any): any;
-export function logoutUser(redirectPath: any, cookies: any): any;
-export function registerUser(user: any, mappers: any): any;
-export function requestPasswordReset(userEmailObject: any): any;
-export function resetPassword(resetPasswordObject: any): any;
-export function changePassword(userId: any, currentPassword: any, newPassword: any): any;
+import { CookieHelper } from '../util/CookieHelper.class';
+export declare const loginUser: (username: string, password: string, cookies?: CookieHelper) => any;
+export declare const logoutUser: (redirectPath?: string, cookies?: CookieHelper) => any;
+export declare const registerUser: (user: any, mappers: any) => any;
+export declare const requestPasswordReset: (userEmailObject: any) => any;
+export declare const resetPassword: (resetPasswordObject: any) => any;
+export declare const changePassword: (userId: any, currentPassword: any, newPassword: any) => any;

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

@@ -1 +1 @@
-export const userSagas: import("redux-saga/effects").ForkEffect<never>[];
+export declare const userSagas: import("redux-saga/effects").ForkEffect<never>[];

package/models/user/redux/sagas/login.d.ts

@@ -1,9 +1,5 @@
-export function handleRequiresLoginSaga(action: any): Generator<import("redux-saga/effects").SelectEffect | import("redux-saga/effects").CallEffect<Generator<import("redux-saga/effects").SelectEffect | Promise<undefined[] | Error[] | {
-    message: string;
-}[] | {
-    message: string;
-    data: any;
-}[]> | import("redux-saga/effects").PutEffect<{
+export declare const loginSagas: import("redux-saga/effects").ForkEffect<never>[];
+export declare function handleRequiresLoginSaga(action: any): Generator<import("redux-saga/effects").SelectEffect | import("redux-saga/effects").CallEffect<Generator<import("redux-saga/effects").SelectEffect | Promise<any[]> | import("redux-saga/effects").PutEffect<{
     type: string;
     authenticationState: {
         isLoading: boolean;
@@ -15,15 +11,8 @@ export function handleRequiresLoginSaga(action: any): Generator<import("redux-sa
         errorMessage: any;
     };
 }> | import("redux-saga/effects").CallEffect<Generator<Promise<{
-    authenticationState: {
-        clientCredentials: null;
-        isAuthenticated: boolean;
-        isAuthenticationError: boolean;
-        isError: boolean;
-    };
-    user: Error | {
-        groups: any;
-    } | null | undefined;
+    authenticationState: import("../../state").AuthenticationState;
+    user: any;
 }> | import("redux-saga/effects").PutEffect<{
     type: string;
     authenticationState: any;
@@ -36,5 +25,4 @@ export function handleRequiresLoginSaga(action: any): Generator<import("redux-sa
     cookies: any;
     securityToken: any;
 }>, any, any>;
-export function refreshSecurityToken(): Generator<any, void, unknown>;
-export const loginSagas: import("redux-saga/effects").ForkEffect<never>[];
+export declare function refreshSecurityToken(): Generator<any, void, unknown>;

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

@@ -1,5 +1,4 @@
-import { StateType } from "../../config";
-import { AppState } from "../../redux/appstate";
+import { AppState, StateType } from "../../models";
 export declare const selectUserIsLoading: (state: AppState) => any;
 export declare const selectUserIsAuthenticated: (state: AppState) => any;
 export declare const selectUserIsAuthenticationError: (state: AppState) => any;

package/models/user/redux/types.d.ts

@@ -1,21 +1,21 @@
-export const VALIDATE_USER: string;
-export const SET_AUTHENTICATION_STATE: string;
-export const LOGIN_USER: string;
-export const LOGIN_SUCCESSFUL: string;
-export const LOGIN_FAILED: string;
-export const LOGOUT_USER: string;
-export const REGISTER_USER: string;
-export const REGISTER_USER_SUCCESS: string;
-export const REGISTER_USER_FAILED: string;
-export const REQUEST_USER_PASSWORD_RESET: string;
-export const RESET_USER_PASSWORD: string;
-export const REQUEST_USER_PASSWORD_RESET_SENDING: string;
-export const REQUEST_USER_PASSWORD_RESET_SUCCESS: string;
-export const REQUEST_USER_PASSWORD_RESET_ERROR: string;
-export const RESET_USER_PASSWORD_SENDING: string;
-export const RESET_USER_PASSWORD_SUCCESS: string;
-export const RESET_USER_PASSWORD_ERROR: string;
-export const CHANGE_USER_PASSWORD: string;
-export const CHANGE_USER_PASSWORD_SENDING: string;
-export const CHANGE_USER_PASSWORD_SUCCESS: string;
-export const CHANGE_USER_PASSWORD_ERROR: string;
+export declare const VALIDATE_USER = "@USER/VALIDATE_USER";
+export declare const SET_AUTHENTICATION_STATE = "@USER/SET_AUTHENTICATION_STATE";
+export declare const LOGIN_USER = "@USER/LOGIN_USER";
+export declare const LOGIN_SUCCESSFUL = "@USER/LOGIN_SUCCESSFUL";
+export declare const LOGIN_FAILED = "@USER/LOGIN_FAILED";
+export declare const LOGOUT_USER = "@USER/LOGOUT_USER";
+export declare const REGISTER_USER = "@USER/REGISTER_USER";
+export declare const REGISTER_USER_SUCCESS = "@USER/REGISTER_USER_SUCCESS";
+export declare const REGISTER_USER_FAILED = "@USER/REGISTER_USER_FAILED";
+export declare const REQUEST_USER_PASSWORD_RESET = "@USER/REQUEST_USER_PASSWORD_RESET";
+export declare const RESET_USER_PASSWORD = "@USER/RESET_USER_PASSWORD";
+export declare const REQUEST_USER_PASSWORD_RESET_SENDING = "@USER/REQUEST_USER_PASSWORD_RESET_SENDING";
+export declare const REQUEST_USER_PASSWORD_RESET_SUCCESS = "@USER/REQUEST_USER_PASSWORD_RESET_SUCCESS";
+export declare const REQUEST_USER_PASSWORD_RESET_ERROR = "@USER/REQUEST_USER_PASSWORD_RESET_ERROR";
+export declare const RESET_USER_PASSWORD_SENDING = "@USER/RESET_USER_PASSWORD_SENDING";
+export declare const RESET_USER_PASSWORD_SUCCESS = "@USER/RESET_USER_PASSWORD_SUCCESS";
+export declare const RESET_USER_PASSWORD_ERROR = "@USER/RESET_USER_PASSWORD_ERROR";
+export declare const CHANGE_USER_PASSWORD = "@USER/CHANGE_USER_PASSWORD";
+export declare const CHANGE_USER_PASSWORD_SENDING = "@USER/CHANGE_USER_PASSWORD_SENDING";
+export declare const CHANGE_USER_PASSWORD_SUCCESS = "@USER/CHANGE_USER_PASSWORD_SUCCESS";
+export declare const CHANGE_USER_PASSWORD_ERROR = "@USER/CHANGE_USER_PASSWORD_ERROR";

package/models/user/state.d.ts

@@ -0,0 +1,12 @@
+import { Group, User } from 'contensis-management-api/lib/models';
+import { ManagementApiClientCredentials } from './util/ContensisManagementApi';
+export type AuthenticationState = {
+    clientCredentials: ManagementApiClientCredentials | null;
+    isAuthenticated: boolean;
+    isAuthenticationError: boolean;
+    isError: boolean;
+    errorMessage?: string | null;
+};
+export type UserWithGroups = User & {
+    groups: Group[];
+};

package/models/user/transformations/mapClientCredentials.d.ts

@@ -1,2 +1,4 @@
-declare function _default(obj: any): any;
+import { Client } from 'contensis-management-api';
+import { ManagementApiClientCredentials } from '../util/ContensisManagementApi';
+declare const _default: (obj: Client) => ManagementApiClientCredentials;
 export default _default;

package/models/user/util/ContensisManagementApi.d.ts

@@ -1,9 +1,10 @@
-export function getManagementApiClient({ bearerToken, bearerTokenExpiryDate, refreshToken, refreshTokenExpiryDate, contensisClassicToken, username, password, }: {
-    bearerToken: any;
-    bearerTokenExpiryDate: any;
-    refreshToken: any;
-    refreshTokenExpiryDate: any;
-    contensisClassicToken: any;
-    username: any;
-    password: any;
-}): Promise<import("contensis-management-api").Client>;
+export type ManagementApiClientCredentials = {
+    bearerToken?: string;
+    bearerTokenExpiryDate?: Date;
+    refreshToken?: string;
+    refreshTokenExpiryDate?: Date;
+    contensisClassicToken?: string;
+    username?: string;
+    password?: string;
+};
+export declare const getManagementApiClient: ({ bearerToken, bearerTokenExpiryDate, refreshToken, refreshTokenExpiryDate, contensisClassicToken, username, password, }: ManagementApiClientCredentials) => Promise<import("contensis-management-api").Client>;

package/models/user/util/CookieConstants.d.ts

@@ -1,3 +1,4 @@
+export declare const BEARER_TOKEN_COOKIE = "ContensisSecurityBearerToken";
 export declare const LOGIN_COOKIE = "ContensisCMSUserName";
 export declare const REFRESH_TOKEN_COOKIE = "RefreshToken";
 export type CookieObject = {

package/models/user/util/CookieHelper.class.d.ts

@@ -1,14 +1,18 @@
+import FallbackCookies from 'universal-cookie';
 type Cookies = {
     [k: string]: string;
 };
 export declare class CookieHelper {
     private cookies;
-    private setCookie;
-    private removeCookie;
+    private set?;
+    private remove?;
+    private update?;
+    private fallback;
     get raw(): Cookies;
-    constructor(cookies: {
+    get cookie(): FallbackCookies;
+    constructor(cookies?: {
         [k: string]: string;
-    }, setCookie: CookieHelper['setCookie'], removeCookie: CookieHelper['removeCookie']);
+    }, setCookie?: CookieHelper['set'], removeCookie?: CookieHelper['remove'], updateCookies?: CookieHelper['update']);
     GetCookie(name: string): string | null;
     SetCookie(name: string, value: string, maxAgeDays?: number): void;
     DeleteCookie(name: string): void;

package/models/user/util/LoginHelper.class.d.ts

@@ -1,54 +1,42 @@
-export class LoginHelper {
+import { ManagementApiClientCredentials } from './ContensisManagementApi';
+import { AuthenticationState, UserWithGroups } from '../state';
+import { Client } from 'contensis-management-api';
+import { CookieHelper } from './CookieHelper.class';
+export declare class LoginHelper {
     static CMS_URL: string;
     static WSFED_LOGIN: boolean;
     static LOGIN_ROUTE: string;
     static ACCESS_DENIED_ROUTE: string;
-    static withCookies: (cookieHelper: any) => LoginHelper;
-    static GetUserDetails: (client: any) => Promise<(Error | {
-        groups: any;
-    } | null)[]>;
-    static ClientRedirectToHome(location: any): void;
-    static ClientRedirectToSignInPage(redirectPath: any): Promise<void>;
+    cookies: CookieHelper;
+    constructor(cookies?: CookieHelper);
+    static withCookies: (cookieHelper: CookieHelper) => LoginHelper;
+    static GetUserDetails: (client: Client) => Promise<[Error | null, UserWithGroups | undefined]>;
+    static ClientRedirectToHome(location?: Location): void;
+    static ClientRedirectToSignInPage(redirectPath?: string): Promise<void>;
     static GetAccessDeniedRoute(originalPath: any): string;
     static ClientRedirectToAccessDeniedPage(originalPath: any): void;
     static ClientRedirectToPath(redirectPath: any): void;
-    static WsFedLogin(redirectUri: any): Promise<void>;
+    static WsFedLogin(redirectUri?: string): Promise<void>;
     static RemoveSecurityTokenQuery(): void;
-    static WsFedLogout(redirectPath: any): Promise<void>;
-    static GetCredentialsForSecurityToken(securityToken: any): Promise<undefined[] | Error[] | {
-        message: string;
-    }[] | {
-        message: string;
-        data: any;
-    }[]>;
-    constructor(cookies: any);
-    cookies: any;
-    SetLoginCookies({ contensisClassicToken, refreshToken }: {
-        contensisClassicToken: any;
-        refreshToken: any;
-    }): void;
+    static WsFedLogout(redirectPath?: string): Promise<void>;
+    static GetCredentialsForSecurityToken(securityToken: string): Promise<any[]>;
+    SetLoginCookies({ bearerToken, contensisClassicToken, refreshToken, }: ManagementApiClientCredentials): void;
     GetCachedCredentials(): {
         bearerToken: null;
         bearerTokenExpiryDate: null;
-        refreshToken: any;
+        refreshToken: string | null;
         refreshTokenExpiryDate: null;
-        contensisClassicToken: any;
+        contensisClassicToken: string | null;
+        securityToken: null;
     };
     ClearCachedCredentials(): void;
-    LoginUser({ username, password, clientCredentials }: {
-        username: any;
-        password: any;
-        clientCredentials: any;
+    LoginUser({ username, password, clientCredentials, }: {
+        username?: string;
+        password?: string;
+        clientCredentials?: ManagementApiClientCredentials;
     }): Promise<{
-        authenticationState: {
-            clientCredentials: null;
-            isAuthenticated: boolean;
-            isAuthenticationError: boolean;
-            isError: boolean;
-        };
-        user: Error | {
-            groups: any;
-        } | null | undefined;
+        authenticationState: AuthenticationState;
+        user: any;
     }>;
-    LogoutUser(redirectPath: any): void;
+    LogoutUser(redirectPath?: string): void;
 }

package/models/user/util/OidcUserManager.d.ts

@@ -16,4 +16,4 @@ export declare const userManagerConfig: {
     scope?: undefined;
     filterProtocolClaims?: undefined;
 };
-export declare const createUserManager: (config: UserManagerSettings) => Promise<{} | undefined>;
+export declare const createUserManager: (config: UserManagerSettings) => Promise<import("oidc-client").UserManager | undefined>;

package/models/user/util/matchGroups.d.ts

@@ -1,3 +1,3 @@
 import { Group } from 'contensis-management-api/lib/models';
-import { RequireLogin } from "../../routing/routes";
+import { RequireLogin } from "../../models";
 export declare const matchUserGroup: (userGroups?: Group[], requiredGroups?: RequireLogin) => boolean;

package/models/util/CachedDeliveryApi.d.ts

@@ -1,25 +1,32 @@
 import { VersionStatus } from 'contensis-core-api';
 import { Client, Query } from 'contensis-delivery-api';
 import { INodeOperations, NodeGetRootOptions } from 'contensis-delivery-api/lib/models';
-import { DeliveryApi } from './ContensisDeliveryApi';
+import { DeliveryApi, SSRContext } from './ContensisDeliveryApi';
 import { LruCache } from './LruCache';
 import { CookieObject } from "../user/util/CookieConstants";
-declare class CachedSearch {
+export declare class CachedSearch {
     cache: LruCache;
     cookies?: CookieObject;
-    constructor(cookies?: CookieObject);
+    ssr?: SSRContext;
+    constructor(ssr?: SSRContext);
     getClient(...args: Parameters<DeliveryApi['getClient']>): Client;
-    search(query: Query, linkDepth?: number, project?: string): Promise<import("contensis-core-api").PagedList<import("contensis-delivery-api/lib/models").Entry>>;
+    search(query: Query, linkDepth?: number, project?: string): Promise<import("contensis-core-api").PagedSearchList<import("contensis-delivery-api").Entry>>;
     searchUsingPost(query: Query, linkDepth?: number, project?: string): any;
-    get(id: string, linkDepth?: number, versionStatus?: VersionStatus, project?: string): Promise<import("contensis-delivery-api/lib/models").Entry>;
+    get(id: string, linkDepth?: number, versionStatus?: VersionStatus, project?: string, fields?: string[]): Promise<import("contensis-delivery-api").Entry>;
     getContentType(id: string, project?: string): Promise<import("contensis-core-api").ContentType>;
-    getRootNode(options: NodeGetRootOptions, project?: string): Promise<import("contensis-delivery-api/lib/models").Node>;
-    getNode(options: Parameters<INodeOperations['get']>[0], project?: string): Promise<import("contensis-delivery-api/lib/models").Node>;
-    getAncestors(options: Parameters<INodeOperations['getAncestors']>[0], project?: string): Promise<import("contensis-delivery-api/lib/models").Node[]>;
-    getChildren(options: Parameters<INodeOperations['getChildren']>[0], project?: string): Promise<import("contensis-delivery-api/lib/models").Node[]>;
-    getSiblings(options: Parameters<INodeOperations['getSiblings']>[0], project?: string): Promise<import("contensis-delivery-api/lib/models").Node[]>;
+    getRootNode(options: NodeGetRootOptions, versionStatus?: VersionStatus, project?: string): Promise<import("contensis-delivery-api").Node<import("contensis-delivery-api").Entry>>;
+    getNode(options: Parameters<INodeOperations['get']>[0], project?: string): Promise<import("contensis-delivery-api").Node<import("contensis-delivery-api").Entry>>;
+    getAncestors(options: Parameters<INodeOperations['getAncestors']>[0], project?: string): Promise<import("contensis-delivery-api").Node<import("contensis-delivery-api").Entry>[]>;
+    getChildren(options: Parameters<INodeOperations['getChildren']>[0], project?: string): Promise<import("contensis-delivery-api").Node<import("contensis-delivery-api").Entry>[]>;
+    getSiblings(options: Parameters<INodeOperations['getSiblings']>[0], project?: string): Promise<import("contensis-delivery-api").Node<import("contensis-delivery-api").Entry>[]>;
     request<T extends () => Promise<any>>(key: string, execute: T): ReturnType<T>;
+    /** Use the cached API for fetch requests */
+    fetch(uri: RequestInfo, opts?: RequestInit): Promise<Response>;
 }
 export declare const cachedSearch: CachedSearch;
-export declare const cachedSearchWithCookies: (cookies?: CookieObject) => CachedSearch;
-export {};
+/** Create a cached search instance attached to the current environment
+ * SSR context and connected to your environment via global variable
+ * `DELIVERY_API_CONFIG`  */
+export declare const cachedSearchWithContext: (ssr?: SSRContext) => CachedSearch;
+/** @deprecated Use cachedSearchWithContext instead */
+export declare const cachedSearchWithCookies: (ssr?: SSRContext) => CachedSearch;

package/models/util/ContensisDeliveryApi.d.ts

@@ -1,21 +1,23 @@
 import { VersionStatus } from 'contensis-core-api';
-import { Client, Query } from 'contensis-delivery-api';
-import { Config } from 'contensis-delivery-api/lib/models';
+import { Client, Config, Query } from 'contensis-delivery-api';
 import { CookieObject } from "../user/util/CookieConstants";
 import { Request } from 'express';
 import { IncomingHttpHeaders } from 'http';
-export declare const getClientConfig: (project?: string, cookies?: CookieObject) => Config;
+import { SSRContext as SSRContextType } from "../models";
+export type SSRContext = Omit<SSRContextType, 'api'>;
+export declare const getClientConfig: (project?: string, ssr?: SSRContext) => Config;
 export declare class DeliveryApi {
     cookies?: CookieObject;
-    constructor(cookies?: CookieObject);
+    ssr?: SSRContext;
+    constructor(ssr?: SSRContext);
     getClientSideVersionStatus: () => any;
-    getServerSideVersionStatus: (request: Request) => string | string[] | import("qs").ParsedQs | import("qs").ParsedQs[];
+    getServerSideVersionStatus: (request: Request) => string | import("qs").ParsedQs | (string | import("qs").ParsedQs)[];
     getVersionStatusFromHeaders: (headers: IncomingHttpHeaders) => string | string[] | null;
     getVersionStatusFromHostname: (currentHostname: string) => "published" | "latest";
-    search: (query: Query, linkDepth?: number, project?: string) => Promise<import("contensis-core-api").PagedList<import("contensis-delivery-api/lib/models").Entry>>;
-    getClient: (versionStatus: VersionStatus | undefined, project: any) => Client;
-    getEntry: (id: string, linkDepth?: number, versionStatus?: VersionStatus, project?: string) => Promise<import("contensis-delivery-api/lib/models").Entry>;
+    search: (query: Query, linkDepth?: number, project?: string) => Promise<import("contensis-core-api").PagedSearchList<import("contensis-delivery-api").Entry>>;
+    getClient: (versionStatus?: VersionStatus, project?: string) => Client;
+    getEntry: (id: string, linkDepth?: number, versionStatus?: VersionStatus, project?: string) => Promise<import("contensis-delivery-api").Entry>;
 }
 export declare const deliveryApi: DeliveryApi;
-export declare const deliveryApiWithCookies: (cookies?: CookieObject) => DeliveryApi;
+export declare const deliveryApiWithCookies: (ssr?: SSRContext) => DeliveryApi;
 export * from './CachedDeliveryApi';

package/models/util/NoSSR.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+/**
+ * NoSSR component to prevent children from rendering on the server.
+ * Renders children only after component has mounted in the browser.
+ */
+export declare const NoSSR: React.FC<React.PropsWithChildren>;

package/models/util/SSRContext.d.ts

@@ -0,0 +1,24 @@
+import { Request, Response } from 'express';
+import React, { PropsWithChildren } from 'react';
+import { SSRAccessMethod, SSRContext as SSRContextType } from "../models";
+/**
+ * SSRContextProvider allows us to hold and access request-scoped references
+ * throughout the component tree
+ *
+ * adding this in client side allows consumers to write universal code and use
+ * the same helpers and request-scoped refs for api, cookies and redux dispatcher
+ * as in SSR */
+export declare const SSRContextProvider: ({ accessMethod, children, request, response, }: PropsWithChildren<{
+    accessMethod?: SSRAccessMethod;
+    request?: Request;
+    response?: Response;
+}>) => React.JSX.Element;
+/**
+ * Server side usage provides access to request-scoped references throughout the component tree
+ *
+ * Client side usage allows consumers to write universal code, using the same
+ * helpers and request-scoped refs for api, cookies and redux dispatcher as in SSR
+ * @returns SSRContextType
+ */
+export declare const useSSRContext: () => SSRContextType;
+export declare const useDeliveryApi: () => import("./CachedDeliveryApi").CachedSearch;