@zengenti/contensis-react-base 2.4.1-beta.7 → 2.5.1-beta.0

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

@@ -0,0 +1,112 @@
+import { List, Map, OrderedMap } from 'immutable';
+import { Context } from '../models/Enums';
+import { Listing } from '../models/Search';
+import { AppState, Tab } from '../models/SearchState';
+import { filtering, initialState, searchFacet, searchTab } from './schema';
+export declare const getSearchContext: (state: AppState) => Context;
+export declare const getCurrent: (state: Map<'search', typeof initialState>, 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 getFacets: (state: AppState) => OrderedMap<string, typeof searchFacet>;
+export declare const getTabFacets: (state: AppState) => OrderedMap<string, OrderedMap<string, string | number | List<any> | Map<string, boolean | List<any>> | Map<string, number | boolean | List<any>> | Map<unknown, unknown> | null>>;
+export declare const getFacetTitles: (state: AppState) => {
+    key: string;
+    title: string | undefined;
+    totalCount: number;
+}[];
+export declare const getFacet: (state: AppState, facetName?: string, context?: Context) => any;
+export declare const getListing: (state: AppState, listing?: string) => Map<string, Listing[keyof Listing]>;
+export declare const getFilters: (state: AppState, facet: string, context?: Context) => Map<string, typeof filtering>;
+export declare const getRenderableFilters: (state: AppState, facet?: string, context?: Context) => Map<string, Map<string, string | boolean | List<import("../models/Search").CustomWhereClause> | List<Map<string, string | boolean>>>>;
+export declare const getFiltersToLoad: (state: AppState, facet: string, context?: Context) => List<string | null>;
+export declare const getSelectedFilters: (state: AppState, facet?: string, context?: Context) => Map<string, List<string>>;
+export declare const getResults: (state: AppState, current?: string, context?: Context) => List<any>;
+export declare const getIsInternalPaging: (state: AppState, current: string, context?: Context) => any;
+export declare const getIsLoaded: (state: AppState, context?: Context, facet?: string | undefined) => boolean;
+export declare const getIsLoading: (state: AppState, context?: Context, facet?: string | undefined) => any;
+export declare const getIsSsr: (state: AppState) => boolean;
+export declare const getFeaturedResults: (state: AppState, current?: string, context?: Context) => any;
+export declare const getPaging: (state: AppState, current?: string, context?: Context) => any;
+export declare const getPageIndex: (state: AppState, current?: string, context?: Context) => number;
+export declare const getPrevPageIndex: (state: AppState, current?: string, context?: Context) => any;
+export declare const getPageIsLoading: (state: AppState, current?: string, context?: Context) => any;
+export declare const getPagesLoaded: (state: AppState, current?: string, context?: Context) => any;
+export declare const getTotalCount: (state: AppState, current?: string, context?: Context) => any;
+export declare const getFacetAuthentication: (state: AppState, facet: string) => any;
+export declare const getFeaturedEntryIds: (state: AppState) => Map<string, string>;
+export declare const getSearchTerm: (state: AppState) => any;
+export declare const getSearchTabs: (state: AppState) => List<typeof searchTab>;
+export declare const getQueryParams: (state: AppState, current?: string, context?: Context) => Map<string, any>;
+export declare const getQueryParameter: ({ state, facet, context, }: {
+    state: AppState;
+    facet?: string | undefined;
+    context?: Context | undefined;
+}, key: string, ifnull?: any) => any;
+export declare const getCustomApi: (state: AppState, current: string, context?: Context) => any;
+export declare const getCustomEnv: (state: AppState, current: string, context?: Context) => any;
+export declare const getTabsAndFacets: (state: AppState) => List<Map<string, string | number | OrderedMap<unknown, unknown> | undefined>>;
+export declare const getSearchTotalCount: (state: AppState) => any;
+export declare const getFacetsTotalCount: (state: AppState) => number;
+export declare const selectFacets: {
+    getCurrent: (state: AppState) => string;
+    getCurrentTab: (state: AppState) => Map<string, Tab[keyof Tab]>;
+    getCustomApi: (state: AppState, current: string, context?: Context) => any;
+    getCustomEnv: (state: AppState, current: string, context?: Context) => any;
+    getFacet: (state: AppState, facetName?: string, context?: Context) => any;
+    getFacetTitles: (state: AppState) => {
+        key: string;
+        title: string | undefined;
+        totalCount: number;
+    }[];
+    getFacets: (state: AppState) => OrderedMap<string, typeof searchFacet>;
+    getFacetsTotalCount: (state: AppState) => number;
+    getFeaturedResults: (state: AppState, current?: string, context?: Context) => any;
+    getFilters: (state: AppState, facet: string, context?: Context) => Map<string, typeof filtering>;
+    getFiltersToLoad: (state: AppState, facet: string, context?: Context) => List<string | null>;
+    getIsLoaded: (state: AppState, context?: Context, facet?: string | undefined) => boolean;
+    getIsLoading: (state: AppState, context?: Context, facet?: string | undefined) => any;
+    getPageIndex: (state: AppState, current?: string, context?: Context) => number;
+    getPageIsLoading: (state: AppState, current?: string, context?: Context) => any;
+    getPagesLoaded: (state: AppState, current?: string, context?: Context) => any;
+    getPaging: (state: AppState, current?: string, context?: Context) => any;
+    getQueryParams: (state: AppState, facet: string) => Map<string, any>;
+    getQueryParameter: ({ state, facet }: {
+        state: AppState;
+        facet: string;
+    }, key: string, ifnull: any) => any;
+    getRenderableFilters: (state: AppState, facet?: string, context?: Context) => Map<string, Map<string, string | boolean | List<import("../models/Search").CustomWhereClause> | List<Map<string, string | boolean>>>>;
+    getResults: (state: AppState, current?: string, context?: Context) => List<any>;
+    getTabFacets: (state: AppState) => OrderedMap<string, OrderedMap<string, string | number | List<any> | Map<string, boolean | List<any>> | Map<string, number | boolean | List<any>> | Map<unknown, unknown> | null>>;
+    getTabsAndFacets: (state: AppState) => List<Map<string, string | number | OrderedMap<unknown, unknown> | undefined>>;
+    getTotalCount: (state: AppState, current?: string, context?: Context) => any;
+    getSearchTabs: (state: AppState) => List<typeof searchTab>;
+    getSearchTerm: (state: AppState) => any;
+    getSearchTotalCount: (state: AppState) => any;
+    getSelectedFilters: (state: AppState, facet?: string, context?: Context) => Map<string, List<string>>;
+};
+export declare const selectListing: {
+    getCurrent: (state: AppState) => string;
+    getFeaturedResults: (state: AppState, listing?: string) => any;
+    getFilters: (state: AppState, listing?: string) => Map<string, Map<string, string | boolean | List<import("../models/Search").CustomWhereClause> | List<Map<string, string | boolean>>>>;
+    getFiltersToLoad: (state: AppState, listing?: string) => List<string | null>;
+    getListing: (state: AppState, listing?: string) => Map<string, Listing[keyof Listing]>;
+    getIsLoaded: (state: AppState) => boolean;
+    getIsLoading: (state: AppState) => any;
+    getPageIndex: (state: AppState, listing?: string) => number;
+    getPaging: (state: AppState, listing?: string) => any;
+    getPageIsLoading: (state: AppState, listing?: string) => any;
+    getPagesLoaded: (state: AppState, listing?: string) => any;
+    getQueryParams: (state: AppState, listing?: string) => Map<string, any>;
+    getQueryParameter: ({ state, facet }: {
+        state: AppState;
+        facet?: string | undefined;
+    }, key: string, ifnull: any) => any;
+    getRenderableFilters: (state: AppState, listing?: string) => Map<string, Map<string, string | boolean | List<import("../models/Search").CustomWhereClause> | List<Map<string, string | boolean>>>>;
+    getResults: (state: AppState, listing?: string) => List<any>;
+    getSearchTerm: (state: AppState) => any;
+    getTotalCount: (state: AppState, listing?: string) => any;
+    getSelectedFilters: (state: AppState, listing?: string) => Map<string, List<string>>;
+};
+export declare const selectCurrentPath: (state: AppState) => any;
+export declare const selectVersionStatus: (state: AppState) => any;

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

@@ -0,0 +1,20 @@
+export declare const APPLY_CONFIG: string;
+export declare const CLEAR_FILTERS: string;
+export declare const DO_SEARCH: string;
+export declare const EXECUTE_SEARCH: string;
+export declare const EXECUTE_SEARCH_ERROR: string;
+export declare const EXECUTE_SEARCH_PRELOAD: string;
+export declare const LOAD_FILTERS: string;
+export declare const LOAD_FILTERS_COMPLETE: string;
+export declare const LOAD_FILTERS_ERROR: string;
+export declare const SET_FEATURED_ENTRIES: string;
+export declare const SET_ROUTE_FILTERS: string;
+export declare const SET_SEARCH_FILTERS: string;
+export declare const SET_SEARCH_ENTRIES: string;
+export declare const SET_SELECTED_FILTER: string;
+export declare const UPDATE_CURRENT_FACET: string;
+export declare const UPDATE_CURRENT_TAB: string;
+export declare const UPDATE_SORT_ORDER: string;
+export declare const UPDATE_PAGE_INDEX: string;
+export declare const UPDATE_SEARCH_TERM: string;
+export declare const UPDATE_SELECTED_FILTERS: string;

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

@@ -0,0 +1,25 @@
+import { SearchQueryOptions } from '../models/Queries';
+import { AppState } from '../models/SearchState';
+import { EnsureSearchAction, SetSearchEntriesAction } from '../models/SearchActions';
+/**
+ * 1, Generates all the parameters required to run the search query.
+ * 2, Tells us if we should run the search.
+ * @param {object} action
+ * @param {ImmutableMap} state
+ * @returns [queryParams, runSearch]
+ */
+export declare const generateQueryParams: (action: EnsureSearchAction | SetSearchEntriesAction, state: AppState) => [SearchQueryOptions, boolean];
+/**
+ * Checks if we have already loaded everything we're asking for and tells us to run the search or not
+ * @param action
+ * @param state
+ */
+export declare const runSearch: (action: EnsureSearchAction | SetSearchEntriesAction, state: AppState, queryParams: SearchQueryOptions) => boolean;
+/**
+ * This will tell us if filter parameters have been
+ * changed by some external event such as a route change
+ * @param action
+ * @returns true or false
+ */
+export declare const filterParamsChanged: (action: EnsureSearchAction | SetSearchEntriesAction, state?: AppState | undefined) => boolean;
+export declare const debugExecuteSearch: (action: EnsureSearchAction | SetSearchEntriesAction, state: AppState) => void;

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

@@ -0,0 +1,32 @@
+export * from "contensis-delivery-api";
+export function GetClientSideDeliveryApiStatus(): "published" | "latest" | null;
+export function GetDeliveryApiStatusFromHostname(currentHostname: any): "published" | "latest";
+export const deliveryApi: DeliveryApi;
+export const cachedSearch: CachedSearch;
+declare class DeliveryApi {
+    search(query: any, linkDepth: any, project: any, env: any): Promise<import("contensis-core-api").PagedList<import("contensis-delivery-api/lib/models").Entry>>;
+    getClient(deliveryApiStatus: string | undefined, project: any, env: any): Client;
+    getEntry(id: any, linkDepth: number | undefined, deliveryApiStatus: string | undefined, project: any, env: any): Promise<import("contensis-delivery-api/lib/models").Entry>;
+}
+declare class CachedSearch {
+    cache: LruCache;
+    taxonomyLookup: {};
+    search(query: any, linkDepth: any, project: any, env: any): any;
+    getTaxonomyNodeByPath(path: any, project: any, env: any): any;
+    request(key: any, execute: any): any;
+    extendTaxonomyNode(node: any): any;
+    getTaxonomyId(node: any): any;
+}
+import { Client } from "contensis-delivery-api";
+declare class LruCache {
+    constructor(limit?: number);
+    map: {};
+    head: any;
+    tail: any;
+    limit: number;
+    size: number;
+    get(key: any): any;
+    set(key: any, value: any): void;
+    setHead(node: any): void;
+    remove(key: any): void;
+}

package/models/search/search/ToJs.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+export declare const toJS: <Props extends {
+    [key: string]: any;
+}>(WrappedComponent: React.ComponentType<Props>) => React.ComponentType<Props>;

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

@@ -0,0 +1,29 @@
+import { IExpression, ILogicalExpression, VersionStatus } from 'contensis-core-api';
+import { CustomWhereClause, WeightedSearchField } from '../models/Search';
+import { FieldOperators } 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 dataFormatExpression: (contentTypeIds: string[], dataFormat?: string) => ILogicalExpression[];
+export declare const featuredResultsExpression: ({ contentTypeId, fieldId, fieldValue, }?: {
+    contentTypeId?: string | string[] | undefined;
+    fieldId?: string | string[] | undefined;
+    fieldValue?: boolean | undefined;
+}) => IExpression[];
+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 excludeIdsExpression: (excludeIds: string[]) => ILogicalExpression[];
+export declare const orderByExpression: (orderBy: string[]) => import("contensis-core-api").ContensisQueryOrderBy;
+/**
+ * Accept HTTP style objects and map them to
+ * their equivalent JS client "Op" expressions
+ * @param {array} where the where array as you'd provide it to the HTTP API
+ * @returns {array} array of constructed Delivery API Operators
+ */
+export declare const customWhereExpressions: (where?: CustomWhereClause | undefined) => IExpression[];
+export declare const termExpressions: (searchTerm: string, weightedSearchFields: WeightedSearchField[]) => any[];

package/models/search/search/performance.d.ts

@@ -0,0 +1 @@
+export declare const now: () => number;

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

@@ -0,0 +1,28 @@
+export declare const DataFormats: {
+    asset: string;
+    entry: string;
+    webpage: string;
+};
+export declare const FilterExpressionTypes: {
+    contentType: string;
+    field: string;
+};
+export declare const Fields: {
+    entryDescription: string;
+    entryTitle: string;
+    keywords: string;
+    searchContent: string;
+    sys: {
+        allUris: string;
+        contentTypeId: string;
+        dataFormat: string;
+        filename: string;
+        id: string;
+        includeInSearch: string;
+        language: string;
+        uri: string;
+        versionStatus: string;
+    };
+    contentTypeId: string;
+    wildcard: string;
+};

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

@@ -0,0 +1,21 @@
+import { Map } from 'immutable';
+import { Entry } from 'contensis-delivery-api/lib/models';
+import { PagedList, Query } from 'contensis-core-api';
+import { CustomApi } from '../models/Search';
+import { TimedSearchResponse } from '../models/SearchUtil';
+export declare function fixFreeTextForElastic(s: string): string;
+export declare const timedSearch: (query: Query, linkDepth?: number, projectId?: string | undefined, env?: string | undefined) => Promise<null | TimedSearchResponse>;
+export declare const getItemsFromResult: (result?: {
+    duration: number;
+    payload: PagedList<Entry> | any[];
+} | undefined) => Entry[];
+export declare const extractQuotedPhrases: (searchTerm: string) => string[];
+export declare const buildUrl: (route: string, params: {
+    [key: string]: string;
+}) => string;
+export declare const callCustomApi: <T>(customApi: Map<string, CustomApi[keyof CustomApi]>, filters: {
+    [key: string]: string;
+}) => Promise<T>;
+export declare const removeEmptyAttributes: (obj: any) => any;
+export declare const toArray: (obj: string, seperator?: string) => string[] | (string & any[]);
+export declare const areArraysEqualSets: (a1: any[], a2: any[]) => boolean;

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

@@ -0,0 +1,2 @@
+export default mapEntriesToFilterItems;
+declare function mapEntriesToFilterItems(entries: any): any;

package/models/search/transformations/filters-to-filterexpression.d.ts

@@ -0,0 +1 @@
+export function mapFiltersToFilterExpression(filters: any, selectedFilters: any): any[];

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

@@ -0,0 +1,2 @@
+export default mapFilterToFilterExpression;
+declare function mapFilterToFilterExpression(filter: any): any;

package/models/search/transformations/searchresult-to-state.mapper.d.ts

@@ -0,0 +1,6 @@
+import { default as mapSearchResultToState } from 'jsonpath-mapper';
+import MappingTemplate from 'jsonpath-mapper/dist/models/Template';
+import { LoadFiltersSearchResults } from '../models/SearchActions';
+export declare const facetTemplate: any;
+export declare const filterTemplate: MappingTemplate<LoadFiltersSearchResults>;
+export default mapSearchResultToState;

package/models/search/transformations/state-to-queryparams.mapper.d.ts

@@ -0,0 +1,12 @@
+import { QueryParams } from '../models/Queries';
+import { AppState } from '../models/SearchState';
+import { Context } from '../models/Enums';
+import { EnsureSearchAction, SetSearchEntriesAction } from '../models/SearchActions';
+declare type QueryParamsMapperParams = {
+    context: Context;
+    facet: string;
+    action: EnsureSearchAction | SetSearchEntriesAction;
+    state: AppState;
+};
+declare const mapStateToQueryParams: (sourceJson: QueryParamsMapperParams) => QueryParams;
+export default mapStateToQueryParams;

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

@@ -0,0 +1,14 @@
+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'];
+};
+export default mapStateToSearchUri;

package/models/server/features/caching/cacheDuration.schema.d.ts

@@ -0,0 +1,7 @@
+export declare const CacheDuration: {
+    200: string;
+    404: string;
+    static: string;
+    expressStatic: string;
+};
+export declare const getCacheDuration: (status?: number) => string;

package/models/server/features/caching/cacheHashing.d.ts

@@ -0,0 +1 @@
+export declare const hashKeys: (keys: any) => string[];

package/models/server/features/caching/setCachingHeaders.d.ts

@@ -0,0 +1,6 @@
+import { Response } from 'express';
+declare const setCachingHeaders: (response: Response, { cacheControl, surrogateControl }: {
+    cacheControl?: string | undefined;
+    surrogateControl?: string | undefined;
+}, method?: string) => void;
+export default setCachingHeaders;

package/models/server/features/response-handler/index.d.ts

@@ -0,0 +1,12 @@
+import { Request, Response } from 'express';
+import { ResponseMethod } from './types';
+/**
+ * Web Application Response handler, sends a prepared express js response
+ * with the supplied content sending in the specified manner
+ * @param {response} request express js request object
+ * @param {response} response express js response object
+ * @param {string | object} content the content to send in the response body
+ * @param {"send" | "json" | "end"} send the response function to call e.g res.send() res.json() res.end()
+ */
+declare const handleResponse: (request: Request, response: Response, content: any, send?: keyof typeof ResponseMethod) => void;
+export default handleResponse;

package/models/server/features/response-handler/types.d.ts

@@ -0,0 +1,5 @@
+export declare const ResponseMethod: {
+    send: string;
+    json: string;
+    end: string;
+};

package/models/server/features/reverse-proxy/index.d.ts

@@ -0,0 +1,4 @@
+import { Express } from 'express';
+export declare const apiProxy: any;
+declare const reverseProxies: (app: Express, reverseProxyPaths?: string[]) => void;
+export default reverseProxies;

package/models/server/features/static-assets/index.d.ts

@@ -0,0 +1,14 @@
+declare const staticAssets: (app: any, { appRootPath, scripts, startupScriptFilename, staticFolderPath, staticRoutePath, staticRoutePaths, }: {
+    appRootPath?: any;
+    scripts?: {
+        attributes?: {
+            [key: string]: string;
+        } | undefined;
+        startup?: string | undefined;
+    } | undefined;
+    startupScriptFilename?: string | undefined;
+    staticFolderPath?: string | undefined;
+    staticRoutePath?: string | undefined;
+    staticRoutePaths?: string[] | undefined;
+}) => void;
+export default staticAssets;

package/models/server/internalServer.d.ts

@@ -0,0 +1,10 @@
+import 'isomorphic-fetch';
+import express from 'express';
+import React from 'react';
+import { ServerConfig } from "../config";
+declare const _default: {
+    app: express.Express;
+    apiProxy: any;
+    start: (ReactApp: React.ComponentType<any>, config: ServerConfig, ServerFeatures: (app: express.Express) => void) => void;
+};
+export default _default;

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

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

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

@@ -0,0 +1,13 @@
+import { RequestHandler } from 'express';
+/**
+ *
+ * @param { appRootPath: string; maxage: number; staticFolderPath: string, startupScriptFilename: string } args
+ * @returns Response | next()
+ * A middleware function to resolve /dist/static/startup.js under a supplied startupScriptFilename variable
+ */
+export declare const resolveStartupMiddleware: ({ appRootPath, maxage, staticFolderPath, startupScriptFilename, }: {
+    appRootPath: string;
+    maxage: string;
+    staticFolderPath: string;
+    startupScriptFilename: string;
+}) => RequestHandler;

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

@@ -0,0 +1,46 @@
+export declare const loadableBundleData: ({ stats, templates }: {
+    stats: any;
+    templates: any;
+}, staticRoutePath: string, build?: string | undefined) => {
+    stats?: string | null | undefined;
+    templates?: {
+        templateHTML: any;
+        templateHTMLStatic: any;
+        templateHTMLFragment: any;
+    } | null | undefined;
+};
+export declare const loadableChunkExtractors: () => {
+    commonLoadableExtractor: {
+        addChunk(chunk: any): void;
+    };
+    modern: any;
+    legacy: any;
+} | undefined;
+export declare const getBundleData: (config: any, staticRoutePath: any) => {
+    default: {
+        stats?: string | null | undefined;
+        templates?: {
+            templateHTML: any;
+            templateHTMLStatic: any;
+            templateHTMLFragment: any;
+        } | null | undefined;
+    };
+    legacy: {
+        stats?: string | null | undefined;
+        templates?: {
+            templateHTML: any;
+            templateHTMLStatic: any;
+            templateHTMLFragment: any;
+        } | null | undefined;
+    };
+    modern: {
+        stats?: string | null | undefined;
+        templates?: {
+            templateHTML: any;
+            templateHTMLStatic: any;
+            templateHTMLFragment: any;
+        } | null | undefined;
+    };
+};
+export declare const buildBundleTags: (bundles: any, differentialBundles?: boolean, staticRoutePath?: string, attributes?: string) => any;
+export declare const getBundleTags: (loadableExtractor: any) => any;

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

@@ -0,0 +1,2 @@
+declare const DisplayStartupConfiguration: (config: any) => void;
+export default DisplayStartupConfiguration;

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

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

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

@@ -0,0 +1 @@
+export declare const replaceStaticPath: (str: string, staticFolderPath?: string) => string;

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

@@ -0,0 +1,2 @@
+declare const _default: (attributes?: {}) => string;
+export default _default;

package/models/server/webApp.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { Express } from 'express';
+import { ServerConfig } from "../config";
+declare const webApp: (app: Express, ReactApp: React.ComponentType<any>, config: ServerConfig & {
+    allowedGroups?: string[];
+    globalGroups?: string[];
+    startupScriptFilename?: string;
+}) => void;
+export default webApp;

package/models/testImmer/redux/reducer.d.ts

@@ -0,0 +1,8 @@
+declare var _default: <Base extends {
+    readonly myTestProp: string;
+    readonly myTestObject: {
+        readonly a: string;
+        readonly b: string;
+    };
+}>(base?: Base | undefined, action?: any) => Base;
+export default _default;

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

@@ -0,0 +1,3 @@
+export function selectTestFeature(state: any): any;
+export function selectGreeting(state: any): any;
+export function selectTestObject(state: any): any;

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

@@ -0,0 +1,2 @@
+declare var _default: (wrappedComponentProps: any) => JSX.Element;
+export default _default;

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

@@ -0,0 +1,16 @@
+export default LoginForm;
+declare function LoginForm({ loginException, authenticationError, loading, loginUser, }: {
+    loginException: any;
+    authenticationError: any;
+    loading: any;
+    loginUser: any;
+}): 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>;
+    }
+}
+import PropTypes from "prop-types";

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

@@ -0,0 +1,12 @@
+export default LogoutForm;
+declare function LogoutForm({ logoutUser, user }: {
+    logoutUser: any;
+    user: any;
+}): JSX.Element;
+declare namespace LogoutForm {
+    namespace propTypes {
+        const logoutUser: PropTypes.Requireable<(...args: any[]) => any>;
+        const user: PropTypes.Requireable<object>;
+    }
+}
+import PropTypes from "prop-types";

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

@@ -0,0 +1,2 @@
+export default LoginStyled;
+declare const LoginStyled: any;

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

@@ -0,0 +1,2 @@
+export default LoginFormStyled;
+declare const LoginFormStyled: any;

package/models/user/containers/ChangePassword.container.d.ts

@@ -0,0 +1,2 @@
+declare var _default: (wrappedComponentProps: any) => JSX.Element;
+export default _default;

package/models/user/containers/ForgotPassword.container.d.ts

@@ -0,0 +1,2 @@
+declare var _default: (wrappedComponentProps: any) => JSX.Element;
+export default _default;

package/models/user/containers/Login.container.d.ts

@@ -0,0 +1,2 @@
+declare var _default: (wrappedComponentProps: any) => JSX.Element;
+export default _default;

package/models/user/containers/Registration.container.d.ts

@@ -0,0 +1,2 @@
+declare var _default: (wrappedComponentProps: any) => JSX.Element;
+export default _default;

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

@@ -0,0 +1,2 @@
+export default withLogin;
+declare function withLogin(WrappedComponent: any): import("react-redux").ConnectedComponent<(wrappedComponentProps: any) => JSX.Element, import("react-redux").Omit<any, "error" | "isLoading" | "authenticationError" | "user" | "loginUser" | "logoutUser" | "isAuthenticated">>;

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

@@ -0,0 +1,2 @@
+export default withRegistration;
+declare function withRegistration(WrappedComponent: any): import("react-redux").ConnectedComponent<(wrappedComponentProps: any) => JSX.Element, import("react-redux").Omit<any, "error" | "isLoading" | "user" | "registerUser" | "isSuccess">>;

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

@@ -0,0 +1,9 @@
+export default useChangePassword;
+declare function useChangePassword(): {
+    isLoading: any;
+    isSuccess: any;
+    userId: any;
+    isLoggedIn: any;
+    error: any;
+    changePassword: (userId: any, currentPassword: any, newPassword: any) => any;
+};

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

@@ -0,0 +1,14 @@
+export default useForgotPassword;
+declare function useForgotPassword(): {
+    isLoading: any;
+    isSuccess: any;
+    error: any;
+    requestPasswordReset: (userEmailObject: any) => any;
+    setNewPassword: {
+        queryString: any;
+        isLoading: any;
+        isSuccess: any;
+        error: any;
+        submit: (resetPasswordObject: any) => any;
+    };
+};