redux-devtools

createDevTools: <
    S,
    A extends Action<unknown>,
    MonitorProps extends LiftedState<S, A, MonitorState>,
    MonitorState,
    MonitorAction extends Action<unknown>
>(
    children: React.ReactElement<MonitorProps, any>
) => {
    new (
        props: Props<S, A, MonitorState, MonitorAction>,
        context: { store?: EnhancedStore<S, A, MonitorState> }
    ): {
        liftedStore?: LiftedStore<S, A, MonitorState> | undefined;
        render(): JSX.Element | null;
        context: any;
        setState<K extends never>(
            state:
                | {}
                | ((
                      prevState: Readonly<{}>,
                      props: Readonly<Props<S, A, MonitorState, MonitorAction>>
                  ) => {} | Pick<{}, K>)
                | Pick<{}, K>,
            callback?: (() => void) | undefined
        ): void;
        forceUpdate(callback?: (() => void) | undefined): void;
        readonly props: Readonly<Props<S, A, MonitorState, MonitorAction>> &
            Readonly<{ children?: React.ReactNode }>;
        state: Readonly<{}>;
        refs: { [key: string]: React.ReactInstance };
        componentDidMount?(): void;
        shouldComponentUpdate?(
            nextProps: Readonly<Props<S, A, MonitorState, MonitorAction>>,
            nextState: Readonly<{}>,
            nextContext: any
        ): boolean;
        componentWillUnmount?(): void;
        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
        getSnapshotBeforeUpdate?(
            prevProps: Readonly<Props<S, A, MonitorState, MonitorAction>>,
            prevState: Readonly<{}>
        ): any;
        componentDidUpdate?(
            prevProps: Readonly<Props<S, A, MonitorState, MonitorAction>>,
            prevState: Readonly<{}>,
            snapshot?: any
        ): void;
        componentWillMount?(): void;
        UNSAFE_componentWillMount?(): void;
        componentWillReceiveProps?(
            nextProps: Readonly<Props<S, A, MonitorState, MonitorAction>>,
            nextContext: any
        ): void;
        UNSAFE_componentWillReceiveProps?(
            nextProps: Readonly<Props<S, A, MonitorState, MonitorAction>>,
            nextContext: any
        ): void;
        componentWillUpdate?(
            nextProps: Readonly<Props<S, A, MonitorState, MonitorAction>>,
            nextState: Readonly<{}>,
            nextContext: any
        ): void;
        UNSAFE_componentWillUpdate?(
            nextProps: Readonly<Props<S, A, MonitorState, MonitorAction>>,
            nextState: Readonly<{}>,
            nextContext: any
        ): void;
    };
    contextTypes: { store: PropTypes.Requireable<object> };
    propTypes: { store: PropTypes.Requireable<object> };
    instrument: (
        options?: Options<S, A, MonitorState, MonitorAction> | undefined
    ) => any;
    contextType?: React.Context<any> | undefined;
};

persistState: <S, A extends Action<unknown>, MonitorState>(
    sessionId?: string | null,
    deserializeState?: (state: S) => S,
    deserializeAction?: (action: A) => A
) => StoreEnhancer;

type Monitor<
    S,
    A extends Action<unknown>,
    MonitorProps extends LiftedState<S, A, MonitorState>,
    MonitorState,
    MonitorAction extends Action<unknown>
> = React.ReactElement<
    MonitorProps,
    React.ComponentType<MonitorProps & LiftedState<S, A, MonitorState>> & {
        update(
            monitorProps: MonitorProps,
            state: MonitorState | undefined,
            action: MonitorAction
        ): MonitorState;
    }
>;