studiokit-scaffolding-js 4.3.20 → 4.3.21

package/lib/components/HOC/DataDependentComponent.d.ts

@@ -1,61 +1,61 @@
-import React, { ComponentClass, ComponentType } from 'react';
-import { BaseReduxState } from '../../types';
-interface DataDependentComponentStateProps {
-    hasData: boolean;
-}
-export declare const configureDataDependentComponent: <TOwnProps extends {}>(WrappedComponent: React.ComponentType<TOwnProps>) => {
-    new (props: (TOwnProps & DataDependentComponentStateProps) | Readonly<TOwnProps & DataDependentComponentStateProps>): {
-        render(): JSX.Element;
-        context: any;
-        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<TOwnProps & DataDependentComponentStateProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
-        forceUpdate(callback?: (() => void) | undefined): void;
-        readonly props: Readonly<TOwnProps & DataDependentComponentStateProps> & Readonly<{
-            children?: React.ReactNode;
-        }>;
-        state: Readonly<{}>;
-        refs: {
-            [key: string]: React.ReactInstance;
-        };
-        componentDidMount?(): void;
-        shouldComponentUpdate?(nextProps: Readonly<TOwnProps & DataDependentComponentStateProps>, nextState: Readonly<{}>, nextContext: any): boolean;
-        componentWillUnmount?(): void;
-        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
-        getSnapshotBeforeUpdate?(prevProps: Readonly<TOwnProps & DataDependentComponentStateProps>, prevState: Readonly<{}>): any;
-        componentDidUpdate?(prevProps: Readonly<TOwnProps & DataDependentComponentStateProps>, prevState: Readonly<{}>, snapshot?: any): void;
-        componentWillMount?(): void;
-        UNSAFE_componentWillMount?(): void;
-        componentWillReceiveProps?(nextProps: Readonly<TOwnProps & DataDependentComponentStateProps>, nextContext: any): void;
-        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<TOwnProps & DataDependentComponentStateProps>, nextContext: any): void;
-        componentWillUpdate?(nextProps: Readonly<TOwnProps & DataDependentComponentStateProps>, nextState: Readonly<{}>, nextContext: any): void;
-        UNSAFE_componentWillUpdate?(nextProps: Readonly<TOwnProps & DataDependentComponentStateProps>, nextState: Readonly<{}>, nextContext: any): void;
-    };
-    new (props: TOwnProps & DataDependentComponentStateProps, context: any): {
-        render(): JSX.Element;
-        context: any;
-        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<TOwnProps & DataDependentComponentStateProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
-        forceUpdate(callback?: (() => void) | undefined): void;
-        readonly props: Readonly<TOwnProps & DataDependentComponentStateProps> & Readonly<{
-            children?: React.ReactNode;
-        }>;
-        state: Readonly<{}>;
-        refs: {
-            [key: string]: React.ReactInstance;
-        };
-        componentDidMount?(): void;
-        shouldComponentUpdate?(nextProps: Readonly<TOwnProps & DataDependentComponentStateProps>, nextState: Readonly<{}>, nextContext: any): boolean;
-        componentWillUnmount?(): void;
-        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
-        getSnapshotBeforeUpdate?(prevProps: Readonly<TOwnProps & DataDependentComponentStateProps>, prevState: Readonly<{}>): any;
-        componentDidUpdate?(prevProps: Readonly<TOwnProps & DataDependentComponentStateProps>, prevState: Readonly<{}>, snapshot?: any): void;
-        componentWillMount?(): void;
-        UNSAFE_componentWillMount?(): void;
-        componentWillReceiveProps?(nextProps: Readonly<TOwnProps & DataDependentComponentStateProps>, nextContext: any): void;
-        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<TOwnProps & DataDependentComponentStateProps>, nextContext: any): void;
-        componentWillUpdate?(nextProps: Readonly<TOwnProps & DataDependentComponentStateProps>, nextState: Readonly<{}>, nextContext: any): void;
-        UNSAFE_componentWillUpdate?(nextProps: Readonly<TOwnProps & DataDependentComponentStateProps>, nextState: Readonly<{}>, nextContext: any): void;
-    };
-    contextType?: React.Context<any> | undefined;
-};
-export declare const configureMapStateToProps: (hasData: (state: BaseReduxState) => boolean) => (state: BaseReduxState) => DataDependentComponentStateProps;
-export default function dataDependentComponent<TOwnProps extends {}>(WrappedComponent: ComponentType<TOwnProps>, hasData: (state: any) => boolean): ComponentClass<TOwnProps>;
-export {};
+import React, { ComponentClass, ComponentType } from 'react';
+import { BaseReduxState } from '../../types';
+interface DataDependentComponentStateProps {
+    hasData: boolean;
+}
+export declare const configureDataDependentComponent: <TOwnProps extends {}>(WrappedComponent: React.ComponentType<TOwnProps>) => {
+    new (props: (TOwnProps & DataDependentComponentStateProps) | Readonly<TOwnProps & DataDependentComponentStateProps>): {
+        render(): JSX.Element;
+        context: any;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<TOwnProps & DataDependentComponentStateProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<TOwnProps & DataDependentComponentStateProps> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<TOwnProps & DataDependentComponentStateProps>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<TOwnProps & DataDependentComponentStateProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<TOwnProps & DataDependentComponentStateProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<TOwnProps & DataDependentComponentStateProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<TOwnProps & DataDependentComponentStateProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<TOwnProps & DataDependentComponentStateProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<TOwnProps & DataDependentComponentStateProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    new (props: TOwnProps & DataDependentComponentStateProps, context: any): {
+        render(): JSX.Element;
+        context: any;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<TOwnProps & DataDependentComponentStateProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<TOwnProps & DataDependentComponentStateProps> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<TOwnProps & DataDependentComponentStateProps>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<TOwnProps & DataDependentComponentStateProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<TOwnProps & DataDependentComponentStateProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<TOwnProps & DataDependentComponentStateProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<TOwnProps & DataDependentComponentStateProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<TOwnProps & DataDependentComponentStateProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<TOwnProps & DataDependentComponentStateProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    contextType?: React.Context<any> | undefined;
+};
+export declare const configureMapStateToProps: (hasData: (state: BaseReduxState) => boolean) => (state: BaseReduxState) => DataDependentComponentStateProps;
+export default function dataDependentComponent<TOwnProps extends {}>(WrappedComponent: ComponentType<TOwnProps>, hasData: (state: any) => boolean): ComponentClass<TOwnProps>;
+export {};

package/lib/components/HOC/DataDependentComponent.js

@@ -1,90 +1,90 @@
-"use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.configureMapStateToProps = exports.configureDataDependentComponent = void 0;
-var react_1 = __importStar(require("react"));
-var react_redux_1 = require("react-redux");
-var Loading_1 = __importDefault(require("../Loading"));
-var configureDataDependentComponent = function (WrappedComponent) {
-    return /** @class */ (function (_super) {
-        __extends(DataDependentComponent, _super);
-        function DataDependentComponent() {
-            return _super !== null && _super.apply(this, arguments) || this;
-        }
-        DataDependentComponent.prototype.render = function () {
-            var _a = this.props, hasData = _a.hasData, ownProps = __rest(_a, ["hasData"]);
-            return this.props.hasData ? react_1.default.createElement(WrappedComponent, __assign({}, ownProps)) : react_1.default.createElement(Loading_1.default, null);
-        };
-        return DataDependentComponent;
-    }(react_1.Component));
-};
-exports.configureDataDependentComponent = configureDataDependentComponent;
-var configureMapStateToProps = function (hasData) { return function (state) {
-    return {
-        hasData: Boolean(!!hasData && hasData(state))
-    };
-}; };
-exports.configureMapStateToProps = configureMapStateToProps;
-function dataDependentComponent(WrappedComponent, hasData) {
-    var DataDependentComponent = exports.configureDataDependentComponent(WrappedComponent);
-    var mapStateToProps = exports.configureMapStateToProps(hasData);
-    // @ts-ignore: could not match inferred type from the `connect` HOC
-    return react_redux_1.connect(mapStateToProps)(DataDependentComponent);
-}
-exports.default = dataDependentComponent;
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureMapStateToProps = exports.configureDataDependentComponent = void 0;
+var react_1 = __importStar(require("react"));
+var react_redux_1 = require("react-redux");
+var Loading_1 = __importDefault(require("../Loading"));
+var configureDataDependentComponent = function (WrappedComponent) {
+    return /** @class */ (function (_super) {
+        __extends(DataDependentComponent, _super);
+        function DataDependentComponent() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        DataDependentComponent.prototype.render = function () {
+            var _a = this.props, hasData = _a.hasData, ownProps = __rest(_a, ["hasData"]);
+            return this.props.hasData ? react_1.default.createElement(WrappedComponent, __assign({}, ownProps)) : react_1.default.createElement(Loading_1.default, null);
+        };
+        return DataDependentComponent;
+    }(react_1.Component));
+};
+exports.configureDataDependentComponent = configureDataDependentComponent;
+var configureMapStateToProps = function (hasData) { return function (state) {
+    return {
+        hasData: Boolean(!!hasData && hasData(state))
+    };
+}; };
+exports.configureMapStateToProps = configureMapStateToProps;
+function dataDependentComponent(WrappedComponent, hasData) {
+    var DataDependentComponent = exports.configureDataDependentComponent(WrappedComponent);
+    var mapStateToProps = exports.configureMapStateToProps(hasData);
+    // @ts-ignore: could not match inferred type from the `connect` HOC
+    return react_redux_1.connect(mapStateToProps)(DataDependentComponent);
+}
+exports.default = dataDependentComponent;

package/lib/components/HOC/EntityComponent.d.ts

@@ -1,83 +1,83 @@
-import React, { ComponentClass, ComponentType } from 'react';
-import { RouteComponentProps } from 'react-router-dom';
-import { BaseReduxState, DeletableModel } from '../../types';
-import { CollectionCommonProps } from '../../types/Collection';
-import { CollectionItemComponentWrappedProps } from './CollectionItemComponent';
-export interface EntityComponentProps<T extends DeletableModel> extends CollectionItemComponentWrappedProps<T>, RouteComponentProps {
-    model: T;
-}
-export declare type EntityComponentWrappedHeaderProps<T extends DeletableModel, TProp extends keyof any> = {
-    [P in TProp]: T;
-};
-export declare type EntityComponentWrappedProps<T extends DeletableModel, TProp extends keyof any> = EntityComponentWrappedHeaderProps<T, TProp> & {
-    modelName: string;
-};
-export declare const configureEntityComponent: <T extends DeletableModel, TPropName extends string | number | symbol>(WrappedComponent: React.ComponentType<EntityComponentWrappedProps<T, TPropName>>, WrappedHeader: React.ComponentClass<EntityComponentWrappedHeaderProps<T, TPropName>, any> | React.FunctionComponent<EntityComponentWrappedHeaderProps<T, TPropName>> | undefined, propName: TPropName, entityName: string) => {
-    new (props: EntityComponentProps<T> | Readonly<EntityComponentProps<T>>): {
-        render(): JSX.Element;
-        context: any;
-        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<EntityComponentProps<T>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
-        forceUpdate(callback?: (() => void) | undefined): void;
-        readonly props: Readonly<EntityComponentProps<T>> & Readonly<{
-            children?: React.ReactNode;
-        }>;
-        state: Readonly<{}>;
-        refs: {
-            [key: string]: React.ReactInstance;
-        };
-        componentDidMount?(): void;
-        shouldComponentUpdate?(nextProps: Readonly<EntityComponentProps<T>>, nextState: Readonly<{}>, nextContext: any): boolean;
-        componentWillUnmount?(): void;
-        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
-        getSnapshotBeforeUpdate?(prevProps: Readonly<EntityComponentProps<T>>, prevState: Readonly<{}>): any;
-        componentDidUpdate?(prevProps: Readonly<EntityComponentProps<T>>, prevState: Readonly<{}>, snapshot?: any): void;
-        componentWillMount?(): void;
-        UNSAFE_componentWillMount?(): void;
-        componentWillReceiveProps?(nextProps: Readonly<EntityComponentProps<T>>, nextContext: any): void;
-        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<EntityComponentProps<T>>, nextContext: any): void;
-        componentWillUpdate?(nextProps: Readonly<EntityComponentProps<T>>, nextState: Readonly<{}>, nextContext: any): void;
-        UNSAFE_componentWillUpdate?(nextProps: Readonly<EntityComponentProps<T>>, nextState: Readonly<{}>, nextContext: any): void;
-    };
-    new (props: EntityComponentProps<T>, context: any): {
-        render(): JSX.Element;
-        context: any;
-        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<EntityComponentProps<T>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
-        forceUpdate(callback?: (() => void) | undefined): void;
-        readonly props: Readonly<EntityComponentProps<T>> & Readonly<{
-            children?: React.ReactNode;
-        }>;
-        state: Readonly<{}>;
-        refs: {
-            [key: string]: React.ReactInstance;
-        };
-        componentDidMount?(): void;
-        shouldComponentUpdate?(nextProps: Readonly<EntityComponentProps<T>>, nextState: Readonly<{}>, nextContext: any): boolean;
-        componentWillUnmount?(): void;
-        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
-        getSnapshotBeforeUpdate?(prevProps: Readonly<EntityComponentProps<T>>, prevState: Readonly<{}>): any;
-        componentDidUpdate?(prevProps: Readonly<EntityComponentProps<T>>, prevState: Readonly<{}>, snapshot?: any): void;
-        componentWillMount?(): void;
-        UNSAFE_componentWillMount?(): void;
-        componentWillReceiveProps?(nextProps: Readonly<EntityComponentProps<T>>, nextContext: any): void;
-        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<EntityComponentProps<T>>, nextContext: any): void;
-        componentWillUpdate?(nextProps: Readonly<EntityComponentProps<T>>, nextState: Readonly<{}>, nextContext: any): void;
-        UNSAFE_componentWillUpdate?(nextProps: Readonly<EntityComponentProps<T>>, nextState: Readonly<{}>, nextContext: any): void;
-    };
-    contextType?: React.Context<any> | undefined;
-};
-export declare const configureMapStateToProps: <T extends DeletableModel>(readActivity: string, modelName: string) => (state: BaseReduxState, ownProps: EntityComponentProps<T>) => {
-    modelName: string;
-};
-/**
- * A wrapper using CollectionItemComponent that passes down the `model`, to allow nesting of collection components.
- * Uses `CollectionItemComponent`, `ModelErrorRedirectComponent`, `withRouter`, and `connect`.
- *
- * This HOC does NOT pass extra props through to children
- *
- * @param WrappedComponent The wrapped component
- * @param WrappedHeader The wrapped header
- * @param readActivity Read activity that will be checked for global access
- * @param modelName Model name passed to wrapped component and `CollectionItemComponent`. May be modified when only global read is available
- * @param propName The name for the prop with which the `model` will be passed to the wrapped component
- */
-export default function entityComponent<T extends DeletableModel, TPropName extends keyof any>(WrappedComponent: ComponentType<EntityComponentWrappedProps<T, TPropName>>, WrappedHeader: ComponentType<EntityComponentWrappedHeaderProps<T, TPropName>> | undefined, readActivity: string, modelName: string, propName: TPropName): ComponentClass<Partial<CollectionCommonProps>>;
+import React, { ComponentClass, ComponentType } from 'react';
+import { RouteComponentProps } from 'react-router-dom';
+import { BaseReduxState, DeletableModel } from '../../types';
+import { CollectionCommonProps } from '../../types/Collection';
+import { CollectionItemComponentWrappedProps } from './CollectionItemComponent';
+export interface EntityComponentProps<T extends DeletableModel> extends CollectionItemComponentWrappedProps<T>, RouteComponentProps {
+    model: T;
+}
+export declare type EntityComponentWrappedHeaderProps<T extends DeletableModel, TProp extends keyof any> = {
+    [P in TProp]: T;
+};
+export declare type EntityComponentWrappedProps<T extends DeletableModel, TProp extends keyof any> = EntityComponentWrappedHeaderProps<T, TProp> & {
+    modelName: string;
+};
+export declare const configureEntityComponent: <T extends DeletableModel, TPropName extends string | number | symbol>(WrappedComponent: React.ComponentType<EntityComponentWrappedProps<T, TPropName>>, WrappedHeader: React.ComponentClass<EntityComponentWrappedHeaderProps<T, TPropName>, any> | React.FunctionComponent<EntityComponentWrappedHeaderProps<T, TPropName>> | undefined, propName: TPropName, entityName: string) => {
+    new (props: EntityComponentProps<T> | Readonly<EntityComponentProps<T>>): {
+        render(): JSX.Element;
+        context: any;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<EntityComponentProps<T>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<EntityComponentProps<T>> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<EntityComponentProps<T>>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<EntityComponentProps<T>>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<EntityComponentProps<T>>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<EntityComponentProps<T>>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<EntityComponentProps<T>>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<EntityComponentProps<T>>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<EntityComponentProps<T>>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    new (props: EntityComponentProps<T>, context: any): {
+        render(): JSX.Element;
+        context: any;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<EntityComponentProps<T>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<EntityComponentProps<T>> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<EntityComponentProps<T>>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<EntityComponentProps<T>>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<EntityComponentProps<T>>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<EntityComponentProps<T>>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<EntityComponentProps<T>>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<EntityComponentProps<T>>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<EntityComponentProps<T>>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    contextType?: React.Context<any> | undefined;
+};
+export declare const configureMapStateToProps: <T extends DeletableModel>(readActivity: string, modelName: string) => (state: BaseReduxState, ownProps: EntityComponentProps<T>) => {
+    modelName: string;
+};
+/**
+ * A wrapper using CollectionItemComponent that passes down the `model`, to allow nesting of collection components.
+ * Uses `CollectionItemComponent`, `ModelErrorRedirectComponent`, `withRouter`, and `connect`.
+ *
+ * This HOC does NOT pass extra props through to children
+ *
+ * @param WrappedComponent The wrapped component
+ * @param WrappedHeader The wrapped header
+ * @param readActivity Read activity that will be checked for global access
+ * @param modelName Model name passed to wrapped component and `CollectionItemComponent`. May be modified when only global read is available
+ * @param propName The name for the prop with which the `model` will be passed to the wrapped component
+ */
+export default function entityComponent<T extends DeletableModel, TPropName extends keyof any>(WrappedComponent: ComponentType<EntityComponentWrappedProps<T, TPropName>>, WrappedHeader: ComponentType<EntityComponentWrappedHeaderProps<T, TPropName>> | undefined, readActivity: string, modelName: string, propName: TPropName): ComponentClass<Partial<CollectionCommonProps>>;