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

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

@@ -1,5 +1,6 @@
+import { FieldLinkDepths, QueryAggregations } from 'contensis-core-api';
 import { Entry } from 'contensis-delivery-api/lib/models';
-import MappingTemplate from 'jsonpath-mapper/dist/models/Template';
+import { MappingTemplate } from 'jsonpath-mapper';
 import { Context } from './Enums';
 import { FieldOperators, LogicOperators } from './Queries';
 import { AppState } from './SearchState';
@@ -96,11 +97,15 @@ export type SearchQueryParams = {
     assetTypes?: string[];
     /** An array of contentTypeIds to search over (sys.dataFormat == 'entry'); Prefix an entry with a "!" to exclude that content type from the search */
     contentTypeIds: string[];
+    /** Any additional field aggregations to add to the search query */
+    customAggregations?: QueryAggregations;
     /** An array of CustomWhereClause to include in the search query */
     customWhere?: CustomWhereClause;
     /** Add parameters to drive an additional set of featured results */
     featuredResults?: FeaturedResults;
     /** An array of fields to return for each entry in the items[] */
+    fieldLinkDepths?: FieldLinkDepths;
+    /** An array of fields to return for each entry in the items[] */
     fields?: string[];
     /** Allows a “fuzzy” search (defaults to `false`) */
     fuzzySearch?: boolean;
@@ -120,6 +125,8 @@ export type SearchQueryParams = {
     pageSize?: number;
     /** Allow a configured minilist to read the search.term set in state (defaults to false) */
     useSearchTerm?: boolean;
+    /** Allow overriding of versionStatus, irrespective of environment */
+    versionStatus?: 'latest' | 'published';
     /** An array of webpageTemplates to search over (sys.dataFormat == 'webpage'); Prefix an entry with a "!" to exclude that webpage template from the search */
     webpageTemplates?: string[];
     /** An array of WeightedSearchField to include in the search query */

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

@@ -2,7 +2,7 @@ import { PagedList } from 'contensis-core-api';
 import { Entry, TaxonomyNode } from 'contensis-delivery-api/lib/models';
 import { Context } from '../models/Enums';
 import { SearchFacet, Listing, Mappers } from '../models/Search';
-import { AppState } from './SearchState';
+import { AppState, Facet } from './SearchState';
 import { QueryParams } from './Queries';
 import { TimedSearchResponse } from './SearchUtil';
 type Action = {
@@ -56,6 +56,7 @@ export type LoadFiltersSearchResults = Action & {
     selectedKeys: string[];
     context: Context;
     mapper: Mappers['filterItems'];
+    facet: Facet;
 };
 export type SearchResults = {
     action: ExecuteSearchAction;
@@ -87,7 +88,7 @@ export type SetSearchEntriesParams = {
     defaultLang: string;
     facet: string;
     mappers: Mappers;
-    nextFacet: SearchFacet;
+    nextFacet: Facet;
     preload: boolean;
     ogState: AppState;
     debug: DebugFlags;

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

@@ -1,3 +1,4 @@
+import { PagedSearchList } from 'contensis-core-api';
 import { Context } from './Enums';
 import { CustomWhereClause } from './Search';
 export type AppState = Record<'search', SearchState> & Record<string, any>;
@@ -12,10 +13,12 @@ export type SearchState = {
     tabs: Tab[];
     config: Record<string, boolean>;
 };
+export type Aggregations = Required<PagedSearchList<unknown>>['aggregations'];
 export type Facets = {
     [key: string]: Facet;
 };
 export type Facet = {
+    aggregations?: Aggregations;
     entries: {
         isLoading: boolean;
         isError: boolean;
@@ -60,7 +63,7 @@ export type Filter = {
     contentTypeId?: string;
     customWhere?: CustomWhereClause;
     defaultValue?: string;
-    fieldId?: string;
+    fieldId?: string | string[];
     isGrouped?: boolean;
     isSingleSelect?: boolean;
     isLoading: boolean;
@@ -77,6 +80,7 @@ export type FilterItem = {
     key: string;
     path?: string;
     isSelected: boolean;
+    aggregate?: number;
 };
 export type SelectedFilters = {
     [k: string]: string[];

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

@@ -1,267 +1,12 @@
 import { SearchConfig } from '../models/Search';
 import { Context } from '../models/Enums';
 import { SearchState } from '../models/SearchState';
-declare const _default: (config: SearchConfig) => <Base extends {
-    readonly context: "facets" | "listings" | "minilist";
-    readonly currentFacet: string;
-    readonly currentListing: string;
-    readonly term: string;
-    readonly facets: {
-        readonly [x: string]: {
-            readonly entries: {
-                readonly isLoading: boolean;
-                readonly isError: boolean;
-                readonly error?: any;
-            };
-            readonly featuredEntries: {
-                readonly isLoading: boolean;
-                readonly isError: boolean;
-                readonly error?: any;
-            };
-            readonly featuredResults: readonly any[];
-            readonly filters: {
-                readonly [x: string]: {
-                    readonly contentTypeId?: string | undefined;
-                    readonly customWhere?: readonly ({
-                        readonly [x: string]: any;
-                        readonly field: string;
-                    } | {
-                        readonly not: {
-                            readonly [x: string]: any;
-                            readonly field: string;
-                        };
-                    } | {
-                        readonly and: readonly {
-                            readonly [x: string]: any;
-                            readonly field: string;
-                        }[];
-                    } | {
-                        readonly or: readonly {
-                            readonly [x: string]: any;
-                            readonly field: string;
-                        }[];
-                    })[] | undefined;
-                    readonly defaultValue?: string | undefined;
-                    readonly fieldId?: string | undefined;
-                    readonly isGrouped?: boolean | undefined;
-                    readonly isSingleSelect?: boolean | undefined;
-                    readonly isLoading: boolean;
-                    readonly isError: boolean;
-                    readonly items?: readonly {
-                        readonly contentTypeId?: string | undefined;
-                        readonly title?: string | undefined;
-                        readonly type?: string | undefined;
-                        readonly key: string;
-                        readonly path?: string | undefined;
-                        readonly isSelected: boolean;
-                    }[] | undefined;
-                    readonly path?: string | undefined;
-                    readonly renderable?: boolean | undefined;
-                    readonly title?: string | undefined;
-                };
-            };
-            readonly pagingInfo: {
-                readonly isLoading: boolean;
-                readonly pageCount: number;
-                readonly pageSize: number;
-                readonly pageIndex: number;
-                readonly pagesLoaded: readonly number[];
-                readonly prevPageIndex: number;
-                readonly totalCount: number;
-            };
-            readonly preloaded: boolean;
-            readonly projectId: string;
-            readonly queryDuration: number;
-            readonly queryParams: {
-                readonly contentTypeIds: readonly string[];
-                readonly dynamicOrderBy: readonly string[];
-                readonly pageSize: number;
-                readonly excludeIds: readonly string[];
-                readonly internalPaging: boolean;
-                readonly loadMorePaging: boolean;
-                readonly useSearchTerm: boolean;
-            };
-            readonly results: readonly any[];
-            readonly tabId: number;
-            readonly title: string;
-        };
-    };
-    readonly listings: {
-        readonly [x: string]: {
-            readonly entries: {
-                readonly isLoading: boolean;
-                readonly isError: boolean;
-                readonly error?: any;
-            };
-            readonly featuredEntries: {
-                readonly isLoading: boolean;
-                readonly isError: boolean;
-                readonly error?: any;
-            };
-            readonly featuredResults: readonly any[];
-            readonly filters: {
-                readonly [x: string]: {
-                    readonly contentTypeId?: string | undefined;
-                    readonly customWhere?: readonly ({
-                        readonly [x: string]: any;
-                        readonly field: string;
-                    } | {
-                        readonly not: {
-                            readonly [x: string]: any;
-                            readonly field: string;
-                        };
-                    } | {
-                        readonly and: readonly {
-                            readonly [x: string]: any;
-                            readonly field: string;
-                        }[];
-                    } | {
-                        readonly or: readonly {
-                            readonly [x: string]: any;
-                            readonly field: string;
-                        }[];
-                    })[] | undefined;
-                    readonly defaultValue?: string | undefined;
-                    readonly fieldId?: string | undefined;
-                    readonly isGrouped?: boolean | undefined;
-                    readonly isSingleSelect?: boolean | undefined;
-                    readonly isLoading: boolean;
-                    readonly isError: boolean;
-                    readonly items?: readonly {
-                        readonly contentTypeId?: string | undefined;
-                        readonly title?: string | undefined;
-                        readonly type?: string | undefined;
-                        readonly key: string;
-                        readonly path?: string | undefined;
-                        readonly isSelected: boolean;
-                    }[] | undefined;
-                    readonly path?: string | undefined;
-                    readonly renderable?: boolean | undefined;
-                    readonly title?: string | undefined;
-                };
-            };
-            readonly pagingInfo: {
-                readonly isLoading: boolean;
-                readonly pageCount: number;
-                readonly pageSize: number;
-                readonly pageIndex: number;
-                readonly pagesLoaded: readonly number[];
-                readonly prevPageIndex: number;
-                readonly totalCount: number;
-            };
-            readonly preloaded: boolean;
-            readonly projectId: string;
-            readonly queryDuration: number;
-            readonly queryParams: {
-                readonly contentTypeIds: readonly string[];
-                readonly dynamicOrderBy: readonly string[];
-                readonly pageSize: number;
-                readonly excludeIds: readonly string[];
-                readonly internalPaging: boolean;
-                readonly loadMorePaging: boolean;
-                readonly useSearchTerm: boolean;
-            };
-            readonly results: readonly any[];
-            readonly tabId: number;
-            readonly title: string;
-        };
-    };
-    readonly minilist: {
-        readonly [x: string]: {
-            readonly entries: {
-                readonly isLoading: boolean;
-                readonly isError: boolean;
-                readonly error?: any;
-            };
-            readonly featuredEntries: {
-                readonly isLoading: boolean;
-                readonly isError: boolean;
-                readonly error?: any;
-            };
-            readonly featuredResults: readonly any[];
-            readonly filters: {
-                readonly [x: string]: {
-                    readonly contentTypeId?: string | undefined;
-                    readonly customWhere?: readonly ({
-                        readonly [x: string]: any;
-                        readonly field: string;
-                    } | {
-                        readonly not: {
-                            readonly [x: string]: any;
-                            readonly field: string;
-                        };
-                    } | {
-                        readonly and: readonly {
-                            readonly [x: string]: any;
-                            readonly field: string;
-                        }[];
-                    } | {
-                        readonly or: readonly {
-                            readonly [x: string]: any;
-                            readonly field: string;
-                        }[];
-                    })[] | undefined;
-                    readonly defaultValue?: string | undefined;
-                    readonly fieldId?: string | undefined;
-                    readonly isGrouped?: boolean | undefined;
-                    readonly isSingleSelect?: boolean | undefined;
-                    readonly isLoading: boolean;
-                    readonly isError: boolean;
-                    readonly items?: readonly {
-                        readonly contentTypeId?: string | undefined;
-                        readonly title?: string | undefined;
-                        readonly type?: string | undefined;
-                        readonly key: string;
-                        readonly path?: string | undefined;
-                        readonly isSelected: boolean;
-                    }[] | undefined;
-                    readonly path?: string | undefined;
-                    readonly renderable?: boolean | undefined;
-                    readonly title?: string | undefined;
-                };
-            };
-            readonly pagingInfo: {
-                readonly isLoading: boolean;
-                readonly pageCount: number;
-                readonly pageSize: number;
-                readonly pageIndex: number;
-                readonly pagesLoaded: readonly number[];
-                readonly prevPageIndex: number;
-                readonly totalCount: number;
-            };
-            readonly preloaded: boolean;
-            readonly projectId: string;
-            readonly queryDuration: number;
-            readonly queryParams: {
-                readonly contentTypeIds: readonly string[];
-                readonly dynamicOrderBy: readonly string[];
-                readonly pageSize: number;
-                readonly excludeIds: readonly string[];
-                readonly internalPaging: boolean;
-                readonly loadMorePaging: boolean;
-                readonly useSearchTerm: boolean;
-            };
-            readonly results: readonly any[];
-            readonly tabId: number;
-            readonly title: string;
-        };
-    };
-    readonly tabs: readonly {
-        readonly currentFacet: string;
-        readonly defaultFacet: string;
-        readonly id: number;
-        readonly label: string;
-        readonly totalCount: number;
-    }[];
-    readonly config: {
-        readonly [x: string]: boolean;
-    };
-}>(base?: Base | undefined, action: {
+declare const _default: (config: SearchConfig) => (state?: SearchState | undefined, action: {
     [key: string]: any;
     context: keyof typeof Context;
     facet: string;
     params: {
         [key: string]: string;
     };
-}) => import("immer/dist/internal").WritableDraft<SearchState> | Base;
+}) => SearchState;
 export default _default;

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

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

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

@@ -40,10 +40,10 @@ export declare const getTotalCount: (state: AppState, current?: string, context?
 export declare const getSearchTerm: (state: AppState) => string;
 export declare const getSearchTabs: (state: AppState, returnType?: StateType) => Tab[];
 export declare const getQueryParams: (state: AppState, current?: string, context?: Context) => Record<string, any>;
-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, }: {
+export declare const getQueryParameter: <K extends keyof SearchQueryParams, K2 extends "projectId" | "linkDepth" | "internalPaging" | "loadMorePaging" | keyof import("../models/Queries").SearchQueryOptions | "env" | "internalPageIndex" | "pagesLoaded" | "prevPageIndex" | "selectedFilters">({ state, facet, context, }: {
     state: AppState;
-    facet?: string | undefined;
-    context?: Context | undefined;
+    facet?: string;
+    context?: Context;
 }, key: K | K2, ifnull?: any) => SearchQueryParams[K] | QueryParams2[K2];
 export declare const getCustomApi: (state: AppState, current: string, context?: Context, returnType?: StateType) => CustomApi;
 export declare const getCustomEnv: (state: AppState, current: string, context?: Context) => any;
@@ -76,7 +76,7 @@ export declare const selectFacets: {
     getQueryParams: (state: AppState, facet: string) => Record<string, any>;
     getQueryParameter: ({ state, facet }: {
         state: AppState;
-        facet?: string | undefined;
+        facet?: string;
     }, 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) => any[];
@@ -105,7 +105,7 @@ export declare const selectListing: {
     getQueryParams: (state: AppState, listing?: string) => Record<string, any>;
     getQueryParameter: ({ state, facet }: {
         state: AppState;
-        facet?: string | undefined;
+        facet?: string;
     }, key: keyof SearchQueryParams | keyof QueryParams2, ifnull: any) => any;
     getRenderableFilters: (state: AppState, listing?: string) => Filters;
     getResults: (state: AppState, listing?: string) => any[];

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

@@ -4,9 +4,9 @@ export function GetDeliveryApiStatusFromHostname(currentHostname: any): "publish
 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>>;
+    search(query: any, linkDepth: any, project: any, env: any): Promise<import("contensis-core-api").PagedList<import("contensis-delivery-api").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>;
+    getEntry(id: any, linkDepth: number | undefined, deliveryApiStatus: string | undefined, project: any, env: any): Promise<import("contensis-delivery-api").Entry>;
 }
 declare class CachedSearch {
     cache: LruCache;

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

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

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

@@ -6,9 +6,9 @@ export declare const contentTypeIdExpression: (contentTypeIds: string[], webpage
 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;
-    fieldId?: string | string[] | undefined;
-    fieldValue?: boolean | undefined;
+    contentTypeId?: string | string[];
+    fieldId?: string | string[];
+    fieldValue?: boolean;
 }) => IExpression[];
 export declare const languagesExpression: (languages: string[]) => IExpression[];
 export declare const includeInSearchExpressions: (webpageTemplates: string[], includeInSearchFields: string[]) => IExpression[];

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

@@ -3,6 +3,21 @@ import { PagedList, Query } from 'contensis-core-api';
 import { CustomApi } from '../models/Search';
 import { TimedSearchResponse } from '../models/SearchUtil';
 export declare function fixFreeTextForElastic(s: string): string;
+/** `convertKeyForAggregation` and `parseKeyForAggregation` exists to prevent an
+ *  auto-generated aggregation using a reserved keyword because Elasticsearch has a list of
+ *  reserved keywords when it parses the response:
+ *  `'location' is one of the reserved aggregation keywords we use a heuristics based
+ *  response parser and using these reserved keywords could throw its heuristics off
+ *  course. We are working on a solution in Elasticsearch itself to make the response
+ *  parseable. For now these are all the reserved keywords: after_key, _as_string,
+ *  bg_count, bottom_right, bounds, buckets, count, doc_count, doc_count_error_upper_bound,
+ *  fields, from, top, type, from_as_string, hits, key, key_as_string, keys, location,
+ *  max_score, meta, min, min_length, score, sum_other_doc_count, to, to_as_string, top_left,
+ *  total, value, value_as_string, values, geometry, properties`
+ */
+export declare const convertKeyForAggregation: (key: string) => string;
+export declare const parseKeyForAggregation: (key: string) => string;
+export declare const convertFieldIdForAggregation: (fieldId: string) => string;
 export declare const timedSearch: (query: Query, linkDepth?: number, projectId?: string, env?: string) => Promise<null | TimedSearchResponse>;
 export declare const getItemsFromResult: (result?: {
     duration: number;
@@ -24,8 +39,8 @@ export declare const routeParams: (staticRoute?: any, location?: {
     [key: string]: any;
     pathname: string;
     search: string;
-    hash?: string | undefined;
-} | undefined) => any;
+    hash?: string;
+}) => any;
 export declare const callCustomApi: <T>(customApi: CustomApi, filters: {
     [key: string]: string;
 }) => Promise<T>;

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

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

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

@@ -5,3 +5,4 @@ export declare const CacheDuration: {
     expressStatic: string;
 };
 export declare const getCacheDuration: (status?: number) => string;
+export declare const anyUpdateHeader: string;

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

@@ -6,7 +6,7 @@ type WithOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
 type SearchQueryArgs = WithOptional<SearchQueryOptions & {
     idFilters?: SearchQueryOptions['filters'];
     sharedFilters?: SearchQueryOptions['filters'];
-}, 'assetTypes' | 'customWhere' | 'dynamicOrderBy' | 'excludeIds' | 'featuredResults' | 'fields' | 'includeInSearchFields' | 'languages' | 'omitDefaultSearchFields' | 'orderBy' | 'pageIndex' | 'searchTerm' | 'webpageTemplates' | 'weightedSearchFields'>;
+}, 'aggregations' | 'assetTypes' | 'customWhere' | 'dynamicOrderBy' | 'excludeIds' | 'featuredResults' | 'fieldLinkDepths' | 'fields' | 'includeInSearchFields' | 'languages' | 'omitDefaultSearchFields' | 'orderBy' | 'pageIndex' | 'searchTerm' | 'webpageTemplates' | 'weightedSearchFields'>;
 /**
  * Builds our complete Delivery API Query object from a set of provided arguments
  * @param queryParams

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

@@ -1,5 +1,5 @@
 declare const staticAssets: (app: any, { appRootPath, scripts, startupScriptFilename, staticFolderPath, staticRoutePath, staticRoutePaths, }: {
-    appRootPath?: any;
+    appRootPath?: string | undefined;
     scripts?: {
         attributes?: {
             [key: string]: string;

package/models/server/internalServer.d.ts

@@ -4,7 +4,7 @@ import { Express } from 'express';
 import http from 'http';
 import React from 'react';
 import { deliveryProxy } from './features/reverse-proxy';
-import { ServerConfig } from "../config";
+import { ServerConfig } from "../models";
 type Exporting = {
     app: Express;
     apiProxy: typeof deliveryProxy;

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

@@ -1,5 +1,5 @@
 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;
     templates?: {

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/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<any, import("../../../node_modules/redux").UnknownAction, unknown> | 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;