diff --git a/docs/api.md b/docs/api.md
index be180465f..bc8d9c47e 100644
--- a/docs/api.md
+++ b/docs/api.md
@@ -37,8 +37,13 @@ createMigrate(
 ### `type Persistor`
 ```js
 {
+  pause: () => void,
+  persist: () => void,
   purge: () => Promise<void>,
   flush: () => Promise<void>,
+  dispatch: (action: PersistorAction) => PersistorAction,
+  getState: () => PersistorState,
+  subscribe: (callback: PersistorSubscribeCallback) => any
 }
 ```
 
@@ -51,29 +56,32 @@ The Persistor is a redux store unto itself, plus
 ### `type PersistConfig`
 ```js
 {
-  key: string, // the key for the persist
-  storage: Object, // the storage adapter, following the AsyncStorage api
   version?: number, // the state version as an integer (defaults to -1)
+  storage: Object, // the storage adapter, following the AsyncStorage api
+  key: string, // the key for the persist
+  keyPrefix?: string, // will be prefixed to the storage key
   blacklist?: Array<string>, // do not persist these keys
   whitelist?: Array<string>, // only persist these keys
-  migrate?: (Object, number) => Promise<Object>,
   transforms?: Array<Transform>,
   throttle?: number, // ms to throttle state writes
-  keyPrefix?: string, // will be prefixed to the storage key
-  debug?: boolean, // true -> verbose logs
+  migrate?: (Object, number) => Promise<Object>,
   stateReconciler?: false | StateReconciler, // false -> do not automatically reconcile state
+  getStoredState?: (PersistConfig<S, RS, HSS, ESS>) => Promise<PersistedState>
+  debug?: boolean, // true -> verbose logs
   serialize?: boolean, // false -> do not call JSON.parse & stringify when setting & getting from storage
+  deserialize?: boolean | ((any) => any)
+  timeout?: number;
   writeFailHandler?: Function, // will be called if the storage engine fails during setItem()
 }
 ```
 
-Persisting state involves calling setItem() on the storage engine. By default, this will fail silently if the storage/quota is exhausted.  
-Provide a writeFailHandler(error) function to be notified if this occurs.
+Persisting state involves calling `setItem()` on the storage engine. By default, this will fail silently if the storage/quota is exhausted.  
+Provide a `writeFailHandler(error)` function to be notified if this occurs.
 
 ### `type MigrationManifest`
 ```js
 {
-  [number]: (State) => State
+  [string]: (State) => State
 }
 ```
 Where the keys are state version numbers and the values are migration functions to modify state.
diff --git a/package-lock.json b/package-lock.json
index c69c6fd63..e7655a949 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -5,7 +5,8 @@
   "requires": true,
   "packages": {
     "": {
-      "version": "6.0.0",
+      "name": "redux-persist",
+      "version": "6.1.0",
       "license": "MIT",
       "devDependencies": {
         "@babel/core": "^7.15.0",
diff --git a/types/types.d.ts b/types/types.d.ts
deleted file mode 100644
index 65260a3c8..000000000
--- a/types/types.d.ts
+++ /dev/null
@@ -1,151 +0,0 @@
-declare module "redux-persist/es/types" {
-  import { StoreEnhancer } from "redux";
-
-  interface PersistState {
-    version: number;
-    rehydrated: boolean;
-  }
-
-  type PersistedState = {
-    _persist: PersistState;
-  } | undefined;
-
-  type PersistMigrate =
-    (state: PersistedState, currentVersion: number) => Promise<PersistedState>;
-
-  type StateReconciler<S> =
-    (inboundState: any, state: S, reducedState: S, config: PersistConfig<S>) => S;
-
-  /**
-   * @desc
-   * `HSS` means HydratedSubState
-   * `ESS` means EndSubState
-   * `S` means State
-   * `RS` means RawState
-   */
-  interface PersistConfig<S, RS = any, HSS = any, ESS = any> {
-    version?: number;
-    storage: Storage;
-    key: string;
-    /**
-     * @deprecated keyPrefix is going to be removed in v6.
-     */
-    keyPrefix?: string;
-    blacklist?: Array<string>;
-    whitelist?: Array<string>;
-    transforms?: Array<Transform<HSS, ESS, S, RS>>;
-    throttle?: number;
-    migrate?: PersistMigrate;
-    stateReconciler?: false | StateReconciler<S>;
-    /**
-     * @desc Used for migrations.
-     */
-    getStoredState?: (config: PersistConfig<S, RS, HSS, ESS>) => Promise<PersistedState>;
-    debug?: boolean;
-    serialize?: boolean;
-    timeout?: number;
-    writeFailHandler?: (err: Error) => void;
-  }
-
-  interface PersistorOptions {
-    enhancer?: StoreEnhancer<any>;
-    manualPersist?: boolean;
-  }
-
-  interface Storage {
-    getItem(key: string, ...args: Array<any>): any;
-    setItem(key: string, value: any, ...args: Array<any>): any;
-    removeItem(key: string, ...args: Array<any>): any;
-  }
-
-  interface WebStorage extends Storage {
-    /**
-     * @desc Fetches key and returns item in a promise.
-     */
-    getItem(key: string): Promise<string | null>;
-    /**
-     * @desc Sets value for key and returns item in a promise.
-     */
-    setItem(key: string, item: string): Promise<void>;
-    /**
-     * @desc Removes value for key.
-     */
-    removeItem(key: string): Promise<void>;
-  }
-
-  interface MigrationManifest {
-    [key: string]: (state: PersistedState) => PersistedState;
-  }
-
-  /**
-   * @desc
-   * `SS` means SubState
-   * `ESS` means EndSubState
-   * `S` means State
-   */
-  type TransformInbound<SS, ESS, S = any> =
-    (subState: SS, key: keyof S, state: S) => ESS;
-
-  /**
-   * @desc
-   * `SS` means SubState
-   * `HSS` means HydratedSubState
-   * `RS` means RawState
-   */
-  type TransformOutbound<SS, HSS, RS = any> =
-    (state: SS, key: keyof RS, rawState: RS) => HSS;
-
-  interface Transform<HSS, ESS, S = any, RS = any> {
-    in: TransformInbound<HSS, ESS, S>;
-    out: TransformOutbound<ESS, HSS, RS>;
-  }
-
-  type RehydrateErrorType = any;
-
-  interface RehydrateAction {
-    type: 'persist/REHYDRATE';
-    key: string;
-    payload?: object | null;
-    err?: RehydrateErrorType | null;
-  }
-
-  interface Persistoid {
-    update(state: object): void;
-    flush(): Promise<any>;
-  }
-
-  interface RegisterAction {
-    type: 'persist/REGISTER';
-    key: string;
-  }
-
-  type PersistorAction =
-    | RehydrateAction
-    | RegisterAction
-  ;
-
-  interface PersistorState {
-    registry: Array<string>;
-    bootstrapped: boolean;
-  }
-
-  type PersistorSubscribeCallback = () => any;
-
-  /**
-   * A persistor is a redux store unto itself, allowing you to purge stored state, flush all
-   * pending state serialization and immediately write to disk
-   */
-  interface Persistor {
-    pause(): void;
-    persist(): void;
-    purge(): Promise<any>;
-    flush(): Promise<any>;
-    dispatch(action: PersistorAction): PersistorAction;
-    getState(): PersistorState;
-    subscribe(callback: PersistorSubscribeCallback): () => any;
-  }
-}
-
-declare module "redux-persist/lib/types" {
-  export * from "redux-persist/es/types";
-}