redux-devtools-instrument

const ActionCreators: {
    performAction<A extends Action<unknown>>(
        action: A,
        trace?: boolean | ((action: A) => string | undefined),
        traceLimit?: number | undefined,
        toExcludeFromTrace?: Function | undefined
    ): {
        type: 'PERFORM_ACTION';
        action: A;
        timestamp: number;
        stack: string | undefined;
    };
    reset(): ResetAction;
    rollback(): RollbackAction;
    commit(): CommitAction;
    sweep(): SweepAction;
    toggleAction(id: number): ToggleAction;
    setActionsActive(
        start: number,
        end: number,
        active?: boolean
    ): SetActionsActiveAction;
    reorderAction(actionId: number, beforeActionId: number): ReorderAction;
    jumpToState(index: number): JumpToStateAction;
    jumpToAction(actionId: number): JumpToActionAction;
    importState<S, A_1 extends Action<unknown>, MonitorState = null>(
        nextLiftedState: LiftedState<S, A_1, MonitorState> | readonly A_1[],
        noRecompute?: boolean | undefined
    ): ImportStateAction<S, A_1, MonitorState>;
    lockChanges(status: boolean): LockChangesAction;
    pauseRecording(status: boolean): PauseRecordingAction;
};

const ActionTypes: {
    readonly PERFORM_ACTION: 'PERFORM_ACTION';
    readonly RESET: 'RESET';
    readonly ROLLBACK: 'ROLLBACK';
    readonly COMMIT: 'COMMIT';
    readonly SWEEP: 'SWEEP';
    readonly TOGGLE_ACTION: 'TOGGLE_ACTION';
    readonly SET_ACTIONS_ACTIVE: 'SET_ACTIONS_ACTIVE';
    readonly JUMP_TO_STATE: 'JUMP_TO_STATE';
    readonly JUMP_TO_ACTION: 'JUMP_TO_ACTION';
    readonly REORDER_ACTION: 'REORDER_ACTION';
    readonly IMPORT_STATE: 'IMPORT_STATE';
    readonly LOCK_CHANGES: 'LOCK_CHANGES';
    readonly PAUSE_RECORDING: 'PAUSE_RECORDING';
};

const INIT_ACTION: { type: string };

instrument: <
    OptionsS,
    OptionsA extends Action<unknown>,
    MonitorState = null,
    MonitorAction extends Action<unknown> = never
>(
    monitorReducer?: Reducer<MonitorState, MonitorAction>,
    options?: Options<OptionsS, OptionsA, MonitorState, MonitorAction>
) => StoreEnhancer<InstrumentExt<any, any, MonitorState>>;

liftAction: <A extends Action<unknown>>(
    action: A,
    trace?: boolean | ((action: A) => string | undefined),
    traceLimit?: number,
    toExcludeFromTrace?: Function
) => {
    type: 'PERFORM_ACTION';
    action: A;
    timestamp: number;
    stack: string | undefined;
};

liftReducerWith: <
    S,
    A extends Action<unknown>,
    MonitorState,
    MonitorAction extends Action<unknown>
>(
    reducer: Reducer<S, A>,
    initialCommittedState: PreloadedState<S> | undefined,
    monitorReducer: Reducer<MonitorState, MonitorAction>,
    options: Options<S, A, MonitorState, MonitorAction>
) => Reducer<LiftedState<S, A, MonitorState>, LiftedAction<S, A, MonitorState>>;

unliftState: <S, A extends Action<unknown>, MonitorState, NextStateExt>(
    liftedState: LiftedState<S, A, MonitorState> & NextStateExt
) => S & NextStateExt;

unliftStore: <
    S,
    A extends Action<unknown>,
    MonitorState,
    MonitorAction extends Action<unknown>,
    NextExt,
    NextStateExt
>(
    liftedStore: Store<
        LiftedState<S, A, MonitorState> & NextStateExt,
        LiftedAction<S, A, MonitorState>
    > &
        NextExt,
    liftReducer: (
        r: Reducer<S, A>
    ) => Reducer<LiftedState<S, A, MonitorState>, LiftedAction<S, A, MonitorState>>,
    options: Options<S, A, MonitorState, MonitorAction>
) => Store<S & NextStateExt, A> &
    NextExt & {
        liftedStore: Store<
            LiftedState<S, A, MonitorState> & NextStateExt,
            LiftedAction<S, A, MonitorState>
        >;
    };

type EnhancedStore<S, A extends Action<unknown>, MonitorState> = Store<S, A> &
    InstrumentExt<S, A, MonitorState>;

type InstrumentExt<S, A extends Action<unknown>, MonitorState> = {
    liftedStore: LiftedStore<S, A, MonitorState>;
};

type LiftedAction<S, A extends Action<unknown>, MonitorState> =
    | PerformAction<A>
    | ResetAction
    | RollbackAction
    | CommitAction
    | SweepAction
    | ToggleAction
    | SetActionsActiveAction
    | ReorderAction
    | JumpToStateAction
    | JumpToActionAction
    | ImportStateAction<S, A, MonitorState>
    | LockChangesAction
    | PauseRecordingAction;

type LiftedReducer<S, A extends Action<unknown>, MonitorState> = Reducer<
    LiftedState<S, A, MonitorState>,
    LiftedAction<S, A, MonitorState>
>;

type LiftedStore<S, A extends Action<unknown>, MonitorState> = Store<
    LiftedState<S, A, MonitorState>,
    LiftedAction<S, A, MonitorState>
>;