@zengenti/contensis-react-base 3.0.0-beta.8 → 3.0.0-beta.80

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

@@ -1,36 +1,35 @@
 import { Context } from '../models/Enums';
 import { QueryParams as QueryParams2 } from '../models/Queries';
-import { CustomApi, QueryParams } from '../models/Search';
-import { AppState, Facet, Facets, Filters, Paging, Tab } from '../models/SearchState';
+import { CustomApi, SearchQueryParams } from '../models/Search';
+import { AppState, Facet, Facets, Filters, Paging, SelectedFilters, Tab } from '../models/SearchState';
 declare type StateType = 'immutable' | 'js';
 export declare const getSearchContext: (state: AppState) => Context;
 export declare const getCurrent: (state: AppState, context?: Context) => string;
 export declare const getCurrentFacet: (state: AppState) => string;
 export declare const getCurrentListing: (state: AppState) => string;
-export declare const getCurrentTab: (state: AppState) => Map<string, Tab[keyof Tab]>;
+export declare const getCurrentTab: (state: AppState) => number;
 export declare const getFacets: (state: AppState, returnType?: StateType | undefined) => Facets;
 export declare const getTabFacets: (state: AppState) => {
     [k: string]: Facet;
 };
 export declare const getFacetTitles: (state: AppState) => {
+    isSelected: boolean;
     key: string;
     title: string | undefined;
     totalCount: number;
 }[];
-export declare const getFacet: (state: AppState, facetName?: string, context?: Context, returnType?: StateType | undefined) => Facet;
+export declare const getFacet: (state: AppState, facetName?: string, context?: Context | string, returnType?: StateType | undefined) => Facet;
 export declare const getListing: (state: AppState, listing?: string) => Facet;
 export declare const getFilters: (state: AppState, facet: string, context?: Context, returnType?: StateType | undefined) => Filters;
 export declare const getRenderableFilters: (state: AppState, facet?: string, context?: Context) => Filters;
 export declare const getFiltersToLoad: (state: AppState, facet: string, context?: Context, returnType?: StateType | undefined) => string[];
-export declare const getSelectedFilters: (state: AppState, facet?: string, context?: Context, returnType?: StateType | undefined) => {
-    [k: string]: string[];
-};
+export declare const getSelectedFilters: (state: AppState, facet?: string, context?: Context, returnType?: StateType | undefined) => SelectedFilters;
 export declare const getResults: (state: AppState, current?: string, context?: Context, returnType?: StateType | undefined) => any[];
 export declare const getIsInternalPaging: (state: AppState, current: string, context?: Context) => boolean;
 export declare const getIsLoaded: (state: AppState, context?: Context, facet?: string | undefined) => boolean;
 export declare const getIsLoading: (state: AppState, context?: Context, facet?: string | undefined) => boolean;
 export declare const getIsSsr: (state: AppState) => boolean;
-export declare const getFeaturedResults: (state: AppState, current?: string, context?: Context) => any[];
+export declare const getFeaturedResults: (state: AppState, current?: string, context?: Context, returnType?: StateType | undefined) => any[];
 export declare const getPaging: (state: AppState, current?: string, context?: Context, returnType?: StateType | undefined) => Paging;
 export declare const getPageIndex: (state: AppState, current?: string, context?: Context) => number;
 export declare const getPrevPageIndex: (state: AppState, current?: string, context?: Context) => number;
@@ -40,30 +39,31 @@ export declare const getTotalCount: (state: AppState, current?: string, context?
 export declare const getSearchTerm: (state: AppState) => string;
 export declare const getSearchTabs: (state: AppState, returnType?: StateType | undefined) => Tab[];
 export declare const getQueryParams: (state: AppState, current?: string, context?: Context) => Record<string, any>;
-export declare const getQueryParameter: <K extends keyof QueryParams, K2 extends "internalPaging" | "linkDepth" | "loadMorePaging" | keyof import("../models/Queries").SearchQueryOptions | "env" | "internalPageIndex" | "pagesLoaded" | "prevPageIndex" | "projectId" | "selectedFilters">({ state, facet, context, }: {
+export declare const getQueryParameter: <K extends keyof SearchQueryParams, K2 extends "internalPaging" | "linkDepth" | "loadMorePaging" | keyof import("../models/Queries").SearchQueryOptions | "env" | "internalPageIndex" | "pagesLoaded" | "prevPageIndex" | "projectId" | "selectedFilters">({ state, facet, context, }: {
     state: AppState;
     facet?: string | undefined;
     context?: Context | undefined;
-}, key: K | K2, ifnull?: any) => QueryParams[K] | QueryParams2[K2];
+}, key: K | K2, ifnull?: any) => SearchQueryParams[K] | QueryParams2[K2];
 export declare const getCustomApi: (state: AppState, current: string, context?: Context, returnType?: StateType | undefined) => CustomApi;
 export declare const getCustomEnv: (state: AppState, current: string, context?: Context) => any;
 export declare const getTabsAndFacets: (state: AppState, returnType?: StateType | undefined) => any;
-export declare const getSearchTotalCount: (state: AppState) => any;
+export declare const getSearchTotalCount: (state: AppState) => number;
 export declare const getFacetsTotalCount: (state: AppState) => number;
 export declare const selectFacets: {
     getCurrent: (state: AppState) => string;
-    getCurrentTab: (state: AppState) => Map<string, Tab[keyof Tab]>;
+    getCurrentTab: (state: AppState) => number;
     getCustomApi: (state: AppState, current: string, context?: Context, returnType?: StateType | undefined) => CustomApi;
     getCustomEnv: (state: AppState, current: string, context?: Context) => any;
-    getFacet: (state: AppState, facetName?: string, context?: Context, returnType?: StateType | undefined) => Facet;
+    getFacet: (state: AppState, facetName?: string, context?: Context | string, returnType?: StateType | undefined) => Facet;
     getFacetTitles: (state: AppState) => {
+        isSelected: boolean;
         key: string;
         title: string | undefined;
         totalCount: number;
     }[];
     getFacets: (state: AppState, returnType?: StateType | undefined) => Facets;
     getFacetsTotalCount: (state: AppState) => number;
-    getFeaturedResults: (state: AppState, current?: string, context?: Context) => any[];
+    getFeaturedResults: (state: AppState, current?: string, context?: Context, returnType?: StateType | undefined) => any[];
     getFilters: (state: AppState, facet: string, context?: Context, returnType?: StateType | undefined) => Filters;
     getFiltersToLoad: (state: AppState, facet: string, context?: Context, returnType?: StateType | undefined) => string[];
     getIsLoaded: (state: AppState, context?: Context, facet?: string | undefined) => boolean;
@@ -75,8 +75,8 @@ export declare const selectFacets: {
     getQueryParams: (state: AppState, facet: string) => Record<string, any>;
     getQueryParameter: ({ state, facet }: {
         state: AppState;
-        facet: string;
-    }, key: keyof QueryParams | keyof QueryParams2, ifnull: any) => any;
+        facet?: string | undefined;
+    }, key: keyof SearchQueryParams | keyof QueryParams2, ifnull: any) => any;
     getRenderableFilters: (state: AppState, facet?: string, context?: Context) => Filters;
     getResults: (state: AppState, current?: string, context?: Context, returnType?: StateType | undefined) => any[];
     getTabFacets: (state: AppState) => {
@@ -86,10 +86,8 @@ export declare const selectFacets: {
     getTotalCount: (state: AppState, current?: string, context?: Context) => number;
     getSearchTabs: (state: AppState, returnType?: StateType | undefined) => Tab[];
     getSearchTerm: (state: AppState) => string;
-    getSearchTotalCount: (state: AppState) => any;
-    getSelectedFilters: (state: AppState, facet?: string, context?: Context, returnType?: StateType | undefined) => {
-        [k: string]: string[];
-    };
+    getSearchTotalCount: (state: AppState) => number;
+    getSelectedFilters: (state: AppState, facet?: string, context?: Context, returnType?: StateType | undefined) => SelectedFilters;
 };
 export declare const selectListing: {
     getCurrent: (state: AppState) => string;
@@ -107,15 +105,14 @@ export declare const selectListing: {
     getQueryParameter: ({ state, facet }: {
         state: AppState;
         facet?: string | undefined;
-    }, key: keyof QueryParams | keyof QueryParams2, ifnull: any) => any;
+    }, key: keyof SearchQueryParams | keyof QueryParams2, ifnull: any) => any;
     getRenderableFilters: (state: AppState, listing?: string) => Filters;
     getResults: (state: AppState, listing?: string) => any[];
     getSearchTerm: (state: AppState) => string;
     getTotalCount: (state: AppState, listing?: string) => number;
-    getSelectedFilters: (state: AppState, listing?: string) => {
-        [k: string]: string[];
-    };
+    getSelectedFilters: (state: AppState, listing?: string) => SelectedFilters;
 };
 export declare const selectCurrentPath: (state: AppState) => any;
+export declare const selectCurrentProject: (state: AppState) => any;
 export declare const selectVersionStatus: (state: AppState) => any;
 export {};

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

@@ -23,3 +23,4 @@ export declare const runSearch: (action: EnsureSearchAction | SetSearchEntriesAc
  */
 export declare const filterParamsChanged: (action: EnsureSearchAction | SetSearchEntriesAction, state?: AppState | undefined) => boolean;
 export declare const debugExecuteSearch: (action: EnsureSearchAction | SetSearchEntriesAction, state: AppState) => void;
+export declare const scrollTop: (scrollYPos: number) => void;

package/models/search/search/ContensisDeliveryApi.d.ts

@@ -16,6 +16,7 @@ declare class CachedSearch {
     request(key: any, execute: any): any;
     extendTaxonomyNode(node: any): any;
     getTaxonomyId(node: any): any;
+    fetch(uri: any, opts?: {}): any;
 }
 import { Client } from "contensis-delivery-api";
 declare class LruCache {

package/models/search/search/expressions.d.ts

@@ -1,13 +1,9 @@
-import { IExpression, ILogicalExpression, VersionStatus } from 'contensis-core-api';
+import { ContensisQueryOrderBy, IExpression, ILogicalExpression, VersionStatus } from 'contensis-core-api';
 import { CustomWhereClause, WeightedSearchField } from '../models/Search';
-import { FieldOperators } from '../models/Queries';
+import { FieldOperators, FilterExpression } from '../models/Queries';
 export declare const fieldExpression: (field: string | string[], value: any, operator?: FieldOperators, weight?: number | undefined) => IExpression[];
 export declare const contentTypeIdExpression: (contentTypeIds: string[], webpageTemplates?: string[] | undefined, assetTypes?: string[] | undefined) => ILogicalExpression[];
-export declare const filterExpressions: (filters: {
-    key: string;
-    value: string;
-    operator: FieldOperators;
-}[]) => IExpression[];
+export declare const filterExpressions: (filters: FilterExpression[], isOptional?: boolean) => IExpression[];
 export declare const dataFormatExpression: (contentTypeIds: string[], dataFormat?: string) => ILogicalExpression[];
 export declare const featuredResultsExpression: ({ contentTypeId, fieldId, fieldValue, }?: {
     contentTypeId?: string | string[] | undefined;
@@ -17,8 +13,9 @@ export declare const featuredResultsExpression: ({ contentTypeId, fieldId, field
 export declare const languagesExpression: (languages: string[]) => IExpression[];
 export declare const includeInSearchExpressions: (webpageTemplates: string[], includeInSearchFields: string[]) => IExpression[];
 export declare const defaultExpressions: (versionStatus: VersionStatus) => IExpression[];
+export declare const includeIdsExpression: (includeIds: string[]) => IExpression[];
 export declare const excludeIdsExpression: (excludeIds: string[]) => ILogicalExpression[];
-export declare const orderByExpression: (orderBy: string[]) => import("contensis-core-api").ContensisQueryOrderBy;
+export declare const orderByExpression: (orderBy: string[]) => ContensisQueryOrderBy;
 /**
  * Accept HTTP style objects and map them to
  * their equivalent JS client "Op" expressions

package/models/search/search/util.d.ts

@@ -12,6 +12,20 @@ export declare const extractQuotedPhrases: (searchTerm: string) => string[];
 export declare const buildUrl: (route: string, params: {
     [key: string]: string;
 }) => string;
+/**
+ * Returns all params from the current route query string or static route
+ * Supply static route argument if reading parameters from the route path
+ * Supply location argument for the params to be read in SSR
+ * @param staticRoute Matched static route from react-router 5 or 6
+ * @param location location object containing at least pathname and search
+ * @returns Keyed params object
+ */
+export declare const routeParams: (staticRoute?: any, location?: {
+    [key: string]: any;
+    pathname: string;
+    search: string;
+    hash?: string | undefined;
+} | undefined) => any;
 export declare const callCustomApi: <T>(customApi: CustomApi, filters: {
     [key: string]: string;
 }) => Promise<T>;

package/models/search/transformations/entry-to-filteritem.mapper.d.ts

@@ -1,2 +1,3 @@
+import { FilterItemsMapper } from '../models/Search';
+declare const mapEntriesToFilterItems: FilterItemsMapper;
 export default mapEntriesToFilterItems;
-declare function mapEntriesToFilterItems(entries: any): any;

package/models/search/transformations/filter-to-filterexpression.mapper.d.ts

@@ -0,0 +1,6 @@
+import { FilterExpression } from '../models/Queries';
+import { Filter } from '../models/SearchState';
+declare const mapFilterToFilterExpression: (filter: Filter & {
+    selectedValues: string[];
+}) => FilterExpression;
+export default mapFilterToFilterExpression;

package/models/search/transformations/filters-to-filterexpressions.mapper.d.ts

@@ -0,0 +1,3 @@
+import { FilterExpression } from '../models/Queries';
+import { Filters, SelectedFilters } from '../models/SearchState';
+export declare const mapFiltersToFilterExpression: (filters: Filters, selectedFilters: SelectedFilters) => FilterExpression[];

package/models/search/transformations/index.d.ts

@@ -0,0 +1,3 @@
+import { Mappers } from '../models/Search';
+declare const _default: Mappers;
+export default _default;

package/models/search/transformations/queryParams-to-customapi.mapper.d.ts

@@ -0,0 +1,3 @@
+import { QueryParams } from '../models';
+declare const mapQueryParamsToCustomApi: (queryParams: QueryParams) => unknown;
+export default mapQueryParamsToCustomApi;

package/models/search/transformations/state-to-searchuri.d.ts

@@ -1,14 +1,3 @@
-import { AppState } from '../models/SearchState';
-declare type SearchStateParams = {
-    state: AppState;
-    facet?: string;
-    orderBy?: string;
-    pageIndex: number;
-    term?: string;
-};
-declare const mapStateToSearchUri: (params: SearchStateParams) => {
-    path: Location['pathname'];
-    search: Location['search'];
-    hash: Location['hash'];
-};
+import { NavigateMapper } from '../models/Search';
+declare const mapStateToSearchUri: NavigateMapper;
 export default mapStateToSearchUri;

package/models/server/features/linkdepth-api/LinkDepthSearchService.d.ts

@@ -0,0 +1,24 @@
+import { LinkDepthApiConfig, LinkDepthApiFilters, LinkFields } from './api.d';
+import QueryLevelResults from './QueryLevelResults';
+export declare type LinkDepthSearchServiceConstuctorArgs = Partial<LinkDepthApiConfig> & {
+    params: {
+        [key: string]: string | undefined;
+    };
+    debug?: boolean;
+};
+declare class LinkDepthSearchService {
+    contentTypeIds: string[];
+    filters: LinkDepthApiFilters;
+    sharedFilters: LinkDepthApiFilters;
+    linkFields: LinkFields;
+    params: {
+        [key: string]: string | undefined;
+    };
+    debug: boolean;
+    queryLevels: QueryLevelResults[];
+    constructor({ contentTypeId, filters, sharedFilters, linkFields, params, debug, }: LinkDepthSearchServiceConstuctorArgs);
+    DoSearch: () => Promise<any>;
+    RunFinalQueries: () => Promise<any>;
+    private InitQueryLevels;
+}
+export default LinkDepthSearchService;

package/models/server/features/linkdepth-api/QueryLevelResults.d.ts

@@ -0,0 +1,50 @@
+import { PagedList } from 'contensis-core-api';
+import { Entry } from 'contensis-delivery-api/lib/models';
+import { LinkDepthApiFilters, LinkFields } from './api.d';
+declare class QueryLevelResults {
+    level: number;
+    contentTypeIds: string[];
+    linkFieldIds: string[];
+    linkFields: LinkFields;
+    filters: LinkDepthApiFilters;
+    sharedFilters: LinkDepthApiFilters;
+    returnEntries: boolean;
+    resolveFirstParent: boolean;
+    validatedLinks: {
+        contentTypeId: string;
+        linkFieldId: string;
+        entryIds: string[];
+    }[];
+    parent: QueryLevelResults | undefined;
+    children: QueryLevelResults[];
+    runFirstQuery: boolean;
+    runFinalQuery: boolean;
+    private params;
+    private debug;
+    private firstQuery;
+    private firstResults;
+    private finalQuery;
+    private finalResults;
+    constructor({ level, contentTypeIds, linkFields, filters, sharedFilters, returnEntries, resolveFirstParent, params, parent, debug, }: {
+        level: number;
+        contentTypeIds: string[];
+        linkFields: LinkFields;
+        filters: LinkDepthApiFilters;
+        sharedFilters: LinkDepthApiFilters;
+        returnEntries?: boolean;
+        resolveFirstParent?: boolean;
+        params: {
+            [key: string]: string | undefined;
+        };
+        parent?: QueryLevelResults;
+        debug?: boolean;
+    });
+    AddChild: ({ child }: {
+        child: QueryLevelResults;
+    }) => void;
+    RunFirstQuery: () => Promise<void>;
+    RunFinalQuery: () => Promise<void>;
+    GetResultsEntries: () => Entry[];
+    GetResults: () => PagedList<Entry>;
+}
+export default QueryLevelResults;

package/models/server/features/linkdepth-api/api.d.ts

@@ -0,0 +1,12 @@
+import { Express } from 'express';
+import { LinkDepthApiConfig } from './api.d';
+/**
+ * Make a LinkDepth api at the uri specified in middlewareConfig.
+ * The api supports a GET request and specified filters are supplied as query-string parameters.
+ * The response should be a normal Delivery API response.
+ * @param app Express app instance
+ * @param middlewareConfig Middleware configuration that represents the content types we want to search within, any filters that are required and any linkFields we wish to search within to derive a set of search results from the entries that contain the linkFields. Each key inside of linkFields represents another "linkDepth" of entries and we can specify all the same contentTypeId, filters, and linkFields of their own. There is no currently no limit on how deep these linkFields can go
+ * @returns Returns nothing if uri, contentTypeId or linkFields is not set in middlewareConfig
+ */
+declare const makeLinkDepthApi: (app: Express, middlewareConfig: LinkDepthApiConfig) => void;
+export default makeLinkDepthApi;

package/models/server/features/linkdepth-api/events-api.config.d.ts

@@ -0,0 +1,37 @@
+declare const eventsApiConfig: {
+    uri: string;
+    contentTypeId: string;
+    filters: {
+        eventTag: string;
+        researchEntity: string;
+        staffTag: string;
+        studentTag: string;
+        subject: string;
+    };
+    sharedFilters: {
+        selectedDate: {
+            fieldId: string;
+            fieldOperator: string;
+        };
+        futureEventDates: {
+            fieldId: string;
+            fieldOperator: string;
+        };
+    };
+    linkFields: {
+        eventDates: {
+            contentTypeId: string;
+            sharedFilters: {
+                selectedDate: {
+                    fieldId: string;
+                    fieldOperator: string;
+                };
+                futureEventDates: {
+                    fieldId: string;
+                    fieldOperator: string;
+                };
+            };
+        };
+    };
+};
+export default eventsApiConfig;

package/models/server/features/linkdepth-api/search.d.ts

@@ -0,0 +1,31 @@
+import { FilterExpression, SearchQueryOptions } from "../../../search";
+import { Query } from 'contensis-core-api';
+import { Entry } from 'contensis-delivery-api/lib/models';
+import { LinkDepthApiFilters } from './api.d';
+declare type WithOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+declare type SearchQueryArgs = WithOptional<SearchQueryOptions & {
+    idFilters?: SearchQueryOptions['filters'];
+    sharedFilters?: SearchQueryOptions['filters'];
+}, 'assetTypes' | 'customWhere' | 'dynamicOrderBy' | 'excludeIds' | 'featuredResults' | 'fields' | 'includeInSearchFields' | 'languages' | 'orderBy' | 'pageIndex' | 'searchTerm' | 'webpageTemplates' | 'weightedSearchFields'>;
+/**
+ * Builds our complete Delivery API Query object from a set of provided arguments
+ * @param queryParams
+ * @returns Delivery API Query
+ */
+export declare const searchQuery: ({ assetTypes, contentTypeIds, customWhere, fields, filters, idFilters, sharedFilters, pageSize, pageIndex, orderBy, searchTerm, versionStatus, webpageTemplates, weightedSearchFields, }: SearchQueryArgs) => Query;
+export declare const appendSearchQueryFilters: (query: Query, idFilters: FilterExpression[]) => void;
+export declare const finalQuery: ({ assetTypes, contentTypeIds, fields, filters, idFilters, sharedFilters, pageSize, pageIndex, orderBy, searchTerm, versionStatus, webpageTemplates, weightedSearchFields, }: SearchQueryArgs, children: Omit<SearchQueryArgs, 'pageSize' | 'pageIndex' | 'versionStatus'>[]) => Query;
+/**
+ * Create a filter expression from a provided filters configuration object
+ * and populate them based on the presence of that key in params, filter
+ * out any filter keys that do not have a value set in params
+ * @param f filters configuration from any level
+ * @param params request.query object from Express middleware
+ * @returns FilterExpression[] we can use to use with searchQuery function
+ */
+export declare const makeFilterExpressions: (f: LinkDepthApiFilters, params: {
+    [param: string]: string | undefined;
+}) => FilterExpression[];
+export declare const makeDerivedIdsFilterExpression: (prevFieldId: string, entries: Entry[], ownIds?: boolean, alwaysApplyFilter?: boolean) => FilterExpression[];
+export declare const resolveParentEntries: (parentContentTypeIds: string[], replaceContentTypeIds: string[], parentFieldId: string, results: Entry[], params: any, debug: boolean) => Promise<Entry[]>;
+export {};

package/models/server/features/linkdepth-api/util.d.ts

@@ -0,0 +1,11 @@
+import { Entry } from 'contensis-delivery-api/lib/models';
+import { PagedList } from 'contensis-core-api';
+/**
+ * Util class holds our search results helper boilerplate methods
+ */
+export declare class Util {
+    static GetIds(entries: Entry[], fieldId?: string): any[];
+    static GetItems(result: PagedList<Entry>): Entry[];
+    static GetResults(result: PagedList<Entry>): PagedList<Entry> | null;
+}
+export declare const mergeResults: (results: Entry[], parentResults: Entry[], replaceContentTypeIds: string[], linkFieldId: string) => Entry[];

package/models/server/middleware/bundleManipulation.d.ts

@@ -1,6 +1,7 @@
 import { RequestHandler } from 'express';
-export declare const bundleManipulationMiddleware: ({ appRootPath, maxage, staticRoutePath, }: {
+export declare const bundleManipulationMiddleware: ({ appRootPath, maxage, staticFolderPath, staticRoutePath, }: {
     appRootPath: string;
     maxage: string;
+    staticFolderPath: string;
     staticRoutePath: string;
 }) => RequestHandler;

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

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

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

@@ -0,0 +1 @@
+export declare const getVersionInfo: (staticFolderPath: string) => any;

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

@@ -1,9 +1,10 @@
 import { Response } from 'express';
-export declare const addStandardHeaders: (state: any, response: Response, packagejson: any, groups: {
+import { AppState } from "../../redux/appstate";
+export declare const addStandardHeaders: (state: AppState, response: Response, packagejson: any, groups: {
     globalGroups?: any[];
     allowedGroups?: any[];
 }) => void;
-export declare const addVarnishAuthenticationHeaders: (state: any, response: Response, groups?: {
+export declare const addVarnishAuthenticationHeaders: (state: AppState, response: Response, groups?: {
     globalGroups?: any[];
     allowedGroups?: any[];
 }) => void;

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

@@ -1,6 +1,5 @@
 declare var _default: React.ComponentType<{
-    error: any;
-    authenticationError: any;
+    errorMessage: any;
     isAuthenticated: any;
     isLoading: any;
     user: any;

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

@@ -1,6 +1,5 @@
 export default LoginForm;
-declare function LoginForm({ loginException, authenticationError, loading, loginUser, }: {
-    loginException: any;
+declare function LoginForm({ authenticationError, loading, loginUser }: {
     authenticationError: any;
     loading: any;
     loginUser: any;

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

@@ -3,8 +3,10 @@ declare function withLogin(WrappedComponent: any): import("react-redux").Connect
     [key: string]: any;
 }>, import("react-redux").Omit<{
     [key: string]: any;
-}, "error" | "isLoading" | "user" | "authenticationError" | "loginUser" | "logoutUser" | "isAuthenticated"> | import("react-redux").Omit<import("react").ClassAttributes<import("react").Component<{
+} & {
+    children?: import("react").ReactNode;
+}, "error" | "isError" | "isLoading" | "user" | "isAuthenticated" | "isAuthenticationError" | "loginUser" | "logoutUser" | "authenticationError"> | import("react-redux").Omit<import("react").ClassAttributes<import("react").Component<{
     [key: string]: any;
 }, any, any>> & {
     [key: string]: any;
-}, "error" | "isLoading" | "user" | "authenticationError" | "loginUser" | "logoutUser" | "isAuthenticated">>;
+}, "error" | "isError" | "isLoading" | "user" | "isAuthenticated" | "isAuthenticationError" | "loginUser" | "logoutUser" | "authenticationError">>;

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

@@ -3,6 +3,8 @@ declare function withRegistration(WrappedComponent: any): import("react-redux").
     [key: string]: any;
 }>, import("react-redux").Omit<{
     [key: string]: any;
+} & {
+    children?: import("react").ReactNode;
 }, "error" | "isLoading" | "user" | "registerUser" | "isSuccess"> | import("react-redux").Omit<import("react").ClassAttributes<import("react").Component<{
     [key: string]: any;
 }, any, any>> & {

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

@@ -2,11 +2,13 @@ export default useLogin;
 declare function useLogin(): {
     loginUser: (username: any, password: any) => any;
     logoutUser: (redirectPath: any) => any;
-    authenticationError: any;
-    authenticationErrorMessage: any;
-    error: any;
     errorMessage: any;
     isAuthenticated: any;
+    isAuthenticationError: any;
+    isError: any;
     isLoading: any;
     user: any;
+    authenticationError: any;
+    authenticationErrorMessage: any;
+    error: any;
 };

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

@@ -1,12 +1,11 @@
 export declare const initialUserState: {
     authenticationState: {
-        authenticated: boolean;
-        authenticationError: boolean;
-        authenticationErrorMessage: null;
         clientCredentials: null;
-        error: boolean;
         errorMessage: null;
-        loading: boolean;
+        isAuthenticated: boolean;
+        isAuthenticationError: boolean;
+        isError: boolean;
+        isLoading: boolean;
     };
     passwordResetRequest: {
         isSending: boolean;

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

@@ -6,17 +6,14 @@ export function handleRequiresLoginSaga(action: any): Generator<import("redux-sa
 }[]> | import("redux-saga/effects").PutEffect<{
     type: string;
     authenticationState: {
-        error: {
-            message: any;
-            stack: any;
-        };
+        isLoading: boolean;
     };
 }> | import("redux-saga/effects").CallEffect<Generator<Promise<{
     authenticationState: {
-        authenticated: boolean;
-        authenticationError: boolean;
-        error: boolean;
         clientCredentials: null;
+        isAuthenticated: boolean;
+        isAuthenticationError: boolean;
+        isError: boolean;
     };
     user: Error | {
         groups: any;
@@ -28,7 +25,13 @@ export function handleRequiresLoginSaga(action: any): Generator<import("redux-sa
 }>, void, {
     authenticationState: any;
     user: any;
-}>>, any, [any, any]>> | import("redux-saga/effects").PutEffect<{
+}>> | import("redux-saga/effects").PutEffect<{
+    type: string;
+    authenticationState: {
+        isError: boolean;
+        errorMessage: any;
+    };
+}>, any, [any, any]>> | import("redux-saga/effects").PutEffect<{
     type: string;
     securityToken: any;
 }>, void, any>;