diff --git a/src/applyMiddleware.ts b/src/applyMiddleware.ts
index 744ed27895..2f1b4752e9 100644
--- a/src/applyMiddleware.ts
+++ b/src/applyMiddleware.ts
@@ -1,8 +1,6 @@
 import compose from './compose'
 import { Middleware, MiddlewareAPI } from './types/middleware'
-import { AnyAction } from './types/actions'
-import { StoreEnhancer, Dispatch, PreloadedState } from './types/store'
-import { Reducer } from './types/reducers'
+import { StoreEnhancer, Dispatch } from './types/store'
 
 /**
  * Creates a store enhancer that applies middleware to the dispatch method
@@ -55,29 +53,25 @@ export default function applyMiddleware<Ext, S = any>(
 export default function applyMiddleware(
   ...middlewares: Middleware[]
 ): StoreEnhancer<any> {
-  return createStore =>
-    <S, A extends AnyAction>(
-      reducer: Reducer<S, A>,
-      preloadedState?: PreloadedState<S>
-    ) => {
-      const store = createStore(reducer, preloadedState)
-      let dispatch: Dispatch = () => {
-        throw new Error(
-          'Dispatching while constructing your middleware is not allowed. ' +
-            'Other middleware would not be applied to this dispatch.'
-        )
-      }
+  return createStore => (reducer, preloadedState) => {
+    const store = createStore(reducer, preloadedState)
+    let dispatch: Dispatch = () => {
+      throw new Error(
+        'Dispatching while constructing your middleware is not allowed. ' +
+          'Other middleware would not be applied to this dispatch.'
+      )
+    }
 
-      const middlewareAPI: MiddlewareAPI = {
-        getState: store.getState,
-        dispatch: (action, ...args) => dispatch(action, ...args)
-      }
-      const chain = middlewares.map(middleware => middleware(middlewareAPI))
-      dispatch = compose<typeof dispatch>(...chain)(store.dispatch)
+    const middlewareAPI: MiddlewareAPI = {
+      getState: store.getState,
+      dispatch: (action, ...args) => dispatch(action, ...args)
+    }
+    const chain = middlewares.map(middleware => middleware(middlewareAPI))
+    dispatch = compose<typeof dispatch>(...chain)(store.dispatch)
 
-      return {
-        ...store,
-        dispatch
-      }
+    return {
+      ...store,
+      dispatch
     }
+  }
 }
diff --git a/src/combineReducers.ts b/src/combineReducers.ts
index ee005cee88..32527c7e92 100644
--- a/src/combineReducers.ts
+++ b/src/combineReducers.ts
@@ -1,11 +1,11 @@
 import { AnyAction, Action } from './types/actions'
 import {
   ActionFromReducersMapObject,
+  PreloadedStateFromReducersMapObject,
   Reducer,
   ReducersMapObject,
   StateFromReducersMapObject
 } from './types/reducers'
-import { CombinedState } from './types/store'
 
 import ActionTypes from './utils/actionTypes'
 import isPlainObject from './utils/isPlainObject'
@@ -111,18 +111,32 @@ function assertReducerShape(reducers: ReducersMapObject) {
  *   object, and builds a state object with the same shape.
  */
 export default function combineReducers<S>(
-  reducers: ReducersMapObject<S, any>
-): Reducer<CombinedState<S>>
-export default function combineReducers<S, A extends Action = AnyAction>(
-  reducers: ReducersMapObject<S, A>
-): Reducer<CombinedState<S>, A>
+  reducers: ReducersMapObject<S, any, any>
+): Reducer<S, AnyAction, Partial<S>>
+export default function combineReducers<S, PreloadedState = S>(
+  reducers: ReducersMapObject<S, any, PreloadedState>
+): Reducer<S, AnyAction, Partial<PreloadedState>>
+export default function combineReducers<
+  S,
+  A extends Action = AnyAction,
+  PreloadedState = S
+>(
+  reducers: ReducersMapObject<S, A, PreloadedState>
+): Reducer<S, A, Partial<PreloadedState>>
 export default function combineReducers<M extends ReducersMapObject>(
   reducers: M
 ): Reducer<
-  CombinedState<StateFromReducersMapObject<M>>,
-  ActionFromReducersMapObject<M>
+  StateFromReducersMapObject<M>,
+  ActionFromReducersMapObject<M>,
+  Partial<PreloadedStateFromReducersMapObject<M>>
 >
-export default function combineReducers(reducers: ReducersMapObject) {
+export default function combineReducers<M extends ReducersMapObject>(
+  reducers: M
+): Reducer<
+  StateFromReducersMapObject<M>,
+  ActionFromReducersMapObject<M>,
+  Partial<PreloadedStateFromReducersMapObject<M>>
+> {
   const reducerKeys = Object.keys(reducers)
   const finalReducers: ReducersMapObject = {}
   for (let i = 0; i < reducerKeys.length; i++) {
@@ -155,7 +169,9 @@ export default function combineReducers(reducers: ReducersMapObject) {
   }
 
   return function combination(
-    state: StateFromReducersMapObject<typeof reducers> = {},
+    state:
+      | StateFromReducersMapObject<typeof reducers>
+      | Partial<PreloadedStateFromReducersMapObject<typeof reducers>> = {},
     action: AnyAction
   ) {
     if (shapeAssertionError) {
@@ -175,7 +191,7 @@ export default function combineReducers(reducers: ReducersMapObject) {
     }
 
     let hasChanged = false
-    const nextState: StateFromReducersMapObject<typeof reducers> = {}
+    const nextState: Partial<StateFromReducersMapObject<typeof reducers>> = {}
     for (let i = 0; i < finalReducerKeys.length; i++) {
       const key = finalReducerKeys[i]
       const reducer = finalReducers[key]
@@ -191,11 +207,11 @@ export default function combineReducers(reducers: ReducersMapObject) {
             `If you want this reducer to hold no value, you can return null instead of undefined.`
         )
       }
-      nextState[key] = nextStateForKey
+      nextState[key as keyof typeof nextState] = nextStateForKey
       hasChanged = hasChanged || nextStateForKey !== previousStateForKey
     }
     hasChanged =
       hasChanged || finalReducerKeys.length !== Object.keys(state).length
-    return hasChanged ? nextState : state
+    return (hasChanged ? nextState : state) as StateFromReducersMapObject<M>
   }
 }
diff --git a/src/createStore.ts b/src/createStore.ts
index 921b723c5f..db1361c459 100644
--- a/src/createStore.ts
+++ b/src/createStore.ts
@@ -2,7 +2,6 @@ import $$observable from './utils/symbol-observable'
 
 import {
   Store,
-  PreloadedState,
   StoreEnhancer,
   Dispatch,
   Observer,
@@ -76,21 +75,23 @@ export function createStore<
 export function createStore<
   S,
   A extends Action,
+  PreloadedState,
   Ext extends {} = {},
   StateExt extends {} = {}
 >(
-  reducer: Reducer<S, A>,
-  preloadedState?: PreloadedState<S>,
+  reducer: Reducer<S, A, PreloadedState>,
+  preloadedState?: PreloadedState | undefined,
   enhancer?: StoreEnhancer<Ext, StateExt>
 ): Store<S, A, StateExt> & Ext
 export function createStore<
   S,
   A extends Action,
+  PreloadedState,
   Ext extends {} = {},
   StateExt extends {} = {}
 >(
-  reducer: Reducer<S, A>,
-  preloadedState?: PreloadedState<S> | StoreEnhancer<Ext, StateExt>,
+  reducer: Reducer<S, A, PreloadedState>,
+  preloadedState?: PreloadedState | StoreEnhancer<Ext, StateExt> | undefined,
   enhancer?: StoreEnhancer<Ext, StateExt>
 ): Store<S, A, StateExt> & Ext {
   if (typeof reducer !== 'function') {
@@ -128,12 +129,14 @@ export function createStore<
 
     return enhancer(createStore)(
       reducer,
-      preloadedState as PreloadedState<S>
-    ) as Store<S, A, StateExt> & Ext
+      preloadedState as PreloadedState | undefined
+    )
   }
 
   let currentReducer = reducer
-  let currentState = preloadedState as S
+  let currentState: S | PreloadedState | undefined = preloadedState as
+    | PreloadedState
+    | undefined
   let currentListeners: Map<number, ListenerCallback> | null = new Map()
   let nextListeners = currentListeners
   let listenerIdCounter = 0
@@ -315,7 +318,7 @@ export function createStore<
       )
     }
 
-    currentReducer = nextReducer
+    currentReducer = nextReducer as unknown as Reducer<S, A, PreloadedState>
 
     // This action has a similar effect to ActionTypes.INIT.
     // Any reducers that existed in both the new and old rootReducer
@@ -455,21 +458,23 @@ export function legacy_createStore<
 export function legacy_createStore<
   S,
   A extends Action,
+  PreloadedState,
   Ext extends {} = {},
   StateExt extends {} = {}
 >(
-  reducer: Reducer<S, A>,
-  preloadedState?: PreloadedState<S>,
+  reducer: Reducer<S, A, PreloadedState>,
+  preloadedState?: PreloadedState | undefined,
   enhancer?: StoreEnhancer<Ext, StateExt>
 ): Store<S, A, StateExt> & Ext
 export function legacy_createStore<
   S,
   A extends Action,
+  PreloadedState,
   Ext extends {} = {},
   StateExt extends {} = {}
 >(
   reducer: Reducer<S, A>,
-  preloadedState?: PreloadedState<S> | StoreEnhancer<Ext, StateExt>,
+  preloadedState?: PreloadedState | StoreEnhancer<Ext, StateExt> | undefined,
   enhancer?: StoreEnhancer<Ext, StateExt>
 ): Store<S, A, StateExt> & Ext {
   return createStore(reducer, preloadedState as any, enhancer)
diff --git a/src/index.ts b/src/index.ts
index 0fa083343b..154bde77ae 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -9,8 +9,6 @@ import __DO_NOT_USE__ActionTypes from './utils/actionTypes'
 // types
 // store
 export {
-  CombinedState,
-  PreloadedState,
   Dispatch,
   Unsubscribe,
   Observable,
@@ -23,9 +21,10 @@ export {
 // reducers
 export {
   Reducer,
-  ReducerFromReducersMapObject,
   ReducersMapObject,
   StateFromReducersMapObject,
+  PreloadedStateFromReducersMapObject,
+  ReducerFromReducersMapObject,
   ActionFromReducer,
   ActionFromReducersMapObject
 } from './types/reducers'
diff --git a/src/types/reducers.ts b/src/types/reducers.ts
index cd084f203a..d60d135e3f 100644
--- a/src/types/reducers.ts
+++ b/src/types/reducers.ts
@@ -25,19 +25,31 @@ import { Action, AnyAction } from './actions'
  *
  * @template S The type of state consumed and produced by this reducer.
  * @template A The type of actions the reducer can potentially respond to.
+ * @template PreloadedState The type of state consumed by this reducer the first time it's called.
  */
-export type Reducer<S = any, A extends Action = AnyAction> = (
-  state: S | undefined,
-  action: A
-) => S
+export type Reducer<
+  S = any,
+  A extends Action = AnyAction,
+  PreloadedState = S
+> = (state: S | PreloadedState | undefined, action: A) => S
 
 /**
  * Object whose values correspond to different reducer functions.
  *
+ * @template S The combined state of the reducers.
  * @template A The type of actions the reducers can potentially respond to.
+ * @template PreloadedState The combined preloaded state of the reducers.
  */
-export type ReducersMapObject<S = any, A extends Action = AnyAction> = {
-  [K in keyof S]: Reducer<S[K], A>
+export type ReducersMapObject<
+  S = any,
+  A extends Action = AnyAction,
+  PreloadedState = S
+> = {
+  [K in keyof S]: Reducer<
+    S[K],
+    A,
+    K extends keyof PreloadedState ? PreloadedState[K] : never
+  >
 }
 
 /**
@@ -45,35 +57,56 @@ export type ReducersMapObject<S = any, A extends Action = AnyAction> = {
  *
  * @template M Object map of reducers as provided to `combineReducers(map: M)`.
  */
-export type StateFromReducersMapObject<M> = M extends ReducersMapObject
-  ? { [P in keyof M]: M[P] extends Reducer<infer S, any> ? S : never }
-  : never
+export type StateFromReducersMapObject<
+  M extends ReducersMapObject<any, any, any>
+> = {
+  [P in keyof M]: M[P] extends Reducer<infer S, any, any> | undefined
+    ? S
+    : never
+}
 
 /**
- * Infer reducer union type from a `ReducersMapObject`.
+ * Infer a combined preloaded state shape from a `ReducersMapObject`.
  *
  * @template M Object map of reducers as provided to `combineReducers(map: M)`.
  */
-export type ReducerFromReducersMapObject<M> = M extends {
-  [P in keyof M]: infer R
-}
-  ? R extends Reducer<any, any>
-    ? R
+export type PreloadedStateFromReducersMapObject<
+  M extends ReducersMapObject<any, any, any>
+> = {
+  [P in keyof M]: M[P] extends
+    | Reducer<any, any, infer PreloadedState>
+    | undefined
+    ? PreloadedState
     : never
-  : never
+}
+
+/**
+ * Infer reducer union type from a `ReducersMapObject`.
+ *
+ * @template M Object map of reducers as provided to `combineReducers(map: M)`.
+ */
+export type ReducerFromReducersMapObject<
+  M extends ReducersMapObject<any, any, any>
+> = M[keyof M]
 
 /**
  * Infer action type from a reducer function.
  *
  * @template R Type of reducer.
  */
-export type ActionFromReducer<R> = R extends Reducer<any, infer A> ? A : never
+export type ActionFromReducer<R extends Reducer<any, any>> = R extends Reducer<
+  any,
+  infer A,
+  any
+>
+  ? A
+  : never
 
 /**
  * Infer action union type from a `ReducersMapObject`.
  *
  * @template M Object map of reducers as provided to `combineReducers(map: M)`.
  */
-export type ActionFromReducersMapObject<M> = M extends ReducersMapObject
-  ? ActionFromReducer<ReducerFromReducersMapObject<M>>
-  : never
+export type ActionFromReducersMapObject<
+  M extends ReducersMapObject<any, any, any>
+> = ActionFromReducer<ReducerFromReducersMapObject<M>>
diff --git a/src/types/store.ts b/src/types/store.ts
index f071dcb136..3021ff09e1 100644
--- a/src/types/store.ts
+++ b/src/types/store.ts
@@ -2,49 +2,6 @@ import { Action, AnyAction } from './actions'
 import { Reducer } from './reducers'
 import '../utils/symbol-observable'
 
-/**
- * Internal "virtual" symbol used to make the `CombinedState` type unique.
- */
-declare const $CombinedState: unique symbol
-
-/**
- * State base type for reducers created with `combineReducers()`.
- *
- * This type allows the `createStore()` method to infer which levels of the
- * preloaded state can be partial.
- *
- * Because Typescript is really duck-typed, a type needs to have some
- * identifying property to differentiate it from other types with matching
- * prototypes for type checking purposes. That's why this type has the
- * `$CombinedState` symbol property. Without the property, this type would
- * match any object. The symbol doesn't really exist because it's an internal
- * (i.e. not exported), and internally we never check its value. Since it's a
- * symbol property, it's not expected to be unumerable, and the value is
- * typed as always undefined, so its never expected to have a meaningful
- * value anyway. It just makes this type distinguishable from plain `{}`.
- */
-interface EmptyObject {
-  readonly [$CombinedState]?: undefined
-}
-export type CombinedState<S> = EmptyObject & S
-
-/**
- * Recursively makes combined state objects partial. Only combined state _root
- * objects_ (i.e. the generated higher level object with keys mapping to
- * individual reducers) are partial.
- */
-export type PreloadedState<S> = Required<S> extends EmptyObject
-  ? S extends CombinedState<infer S1>
-    ? {
-        [K in keyof S1]?: S1[K] extends object ? PreloadedState<S1[K]> : S1[K]
-      }
-    : S
-  : {
-      [K in keyof S]: S[K] extends string | number | boolean | symbol
-        ? S[K]
-        : PreloadedState<S[K]>
-    }
-
 /**
  * A *dispatching function* (or simply *dispatch function*) is a function that
  * accepts an action or an async action; it then may or may not dispatch one
@@ -214,6 +171,7 @@ export interface Store<
  *
  * @template S The type of state to be held by the store.
  * @template A The type of actions which may be dispatched.
+ * @template PreloadedState The initial state that is passed into the reducer.
  * @template Ext Store extension that is mixed in to the Store type.
  * @template StateExt State extension that is mixed into the state type.
  */
@@ -222,9 +180,15 @@ export interface StoreCreator {
     reducer: Reducer<S, A>,
     enhancer?: StoreEnhancer<Ext, StateExt>
   ): Store<S, A, StateExt> & Ext
-  <S, A extends Action, Ext extends {} = {}, StateExt extends {} = {}>(
-    reducer: Reducer<S, A>,
-    preloadedState?: PreloadedState<S>,
+  <
+    S,
+    A extends Action,
+    PreloadedState,
+    Ext extends {} = {},
+    StateExt extends {} = {}
+  >(
+    reducer: Reducer<S, A, PreloadedState>,
+    preloadedState?: PreloadedState | undefined,
     enhancer?: StoreEnhancer<Ext>
   ): Store<S, A, StateExt> & Ext
 }
@@ -259,7 +223,7 @@ export type StoreEnhancer<Ext extends {} = {}, StateExt extends {} = {}> = <
 export type StoreEnhancerStoreCreator<
   Ext extends {} = {},
   StateExt extends {} = {}
-> = <S = any, A extends Action = AnyAction>(
-  reducer: Reducer<S, A>,
-  preloadedState?: PreloadedState<S>
+> = <S, A extends Action, PreloadedState>(
+  reducer: Reducer<S, A, PreloadedState>,
+  preloadedState?: PreloadedState | undefined
 ) => Store<S, A, StateExt> & Ext
diff --git a/test/createStore.spec.ts b/test/createStore.spec.ts
index ec708b8d76..b19758383a 100644
--- a/test/createStore.spec.ts
+++ b/test/createStore.spec.ts
@@ -847,7 +847,7 @@ describe('createStore', () => {
     const store = createStore(
       combineReducers<{ x?: number; y: { z: number; w?: number } }>({
         x: (s = 0, _) => s,
-        y: combineReducers({
+        y: combineReducers<{ z: number; w?: number }>({
           z: (s = 0, _) => s,
           w: (s = 0, _) => s
         })
diff --git a/test/typescript/enhancers.ts b/test/typescript/enhancers.ts
index 282d5166ed..9771d5ad68 100644
--- a/test/typescript/enhancers.ts
+++ b/test/typescript/enhancers.ts
@@ -15,9 +15,9 @@ function dispatchExtension() {
     dispatch: PromiseDispatch
   }> =
     createStore =>
-    <S, A extends Action = AnyAction>(
-      reducer: Reducer<S, A>,
-      preloadedState?: any
+    <S, A extends Action, PreloadedState>(
+      reducer: Reducer<S, A, PreloadedState>,
+      preloadedState?: PreloadedState | undefined
     ) => {
       const store = createStore(reducer, preloadedState)
       return {
@@ -48,16 +48,18 @@ function dispatchExtension() {
  */
 function stateExtension() {
   interface ExtraState {
-    extraField: 'extra'
+    extraField: string
   }
 
   const enhancer: StoreEnhancer<{}, ExtraState> =
     createStore =>
-    <S, A extends Action = AnyAction>(
-      reducer: Reducer<S, A>,
-      preloadedState?: any
+    <S, A extends Action, PreloadedState>(
+      reducer: Reducer<S, A, PreloadedState>,
+      preloadedState?: PreloadedState | undefined
     ) => {
-      function wrapReducer(reducer: Reducer<S, A>): Reducer<S & ExtraState, A> {
+      function wrapReducer<PreloadedStateToWrap>(
+        reducer: Reducer<S, A, PreloadedStateToWrap>
+      ): Reducer<S & ExtraState, A, PreloadedStateToWrap & ExtraState> {
         return (state, action) => {
           const newState = reducer(state, action)
           return {
@@ -116,16 +118,18 @@ function extraMethods() {
  */
 function replaceReducerExtender() {
   interface ExtraState {
-    extraField: 'extra'
+    extraField: string
   }
 
   const enhancer: StoreEnhancer<{ method(): string }, ExtraState> =
     createStore =>
-    <S, A extends Action = AnyAction>(
-      reducer: Reducer<S, A>,
-      preloadedState?: any
+    <S, A extends Action, PreloadedState>(
+      reducer: Reducer<S, A, PreloadedState>,
+      preloadedState?: PreloadedState | undefined
     ) => {
-      function wrapReducer(reducer: Reducer<S, A>): Reducer<S & ExtraState, A> {
+      function wrapReducer<PreloadedStateToWrap>(
+        reducer: Reducer<S, A, PreloadedStateToWrap>
+      ): Reducer<S & ExtraState, A, PreloadedStateToWrap & ExtraState> {
         return (state, action) => {
           const newState = reducer(state, action)
           return {
@@ -192,16 +196,20 @@ function mhelmersonExample() {
 
   function stateExtensionExpectedToWork() {
     interface ExtraState {
-      extraField: 'extra'
+      extraField: string
     }
 
     const enhancer: StoreEnhancer<{}, ExtraState> =
       createStore =>
-      <S, A extends Action = AnyAction>(
-        reducer: Reducer<S, A>,
-        preloadedState?: any
+      <S, A extends Action, PreloadedState>(
+        reducer: Reducer<S, A, PreloadedState>,
+        preloadedState?: PreloadedState | undefined
       ) => {
-        const wrappedReducer: Reducer<S & ExtraState, A> = (state, action) => {
+        const wrappedReducer: Reducer<
+          S & ExtraState,
+          A,
+          PreloadedState & ExtraState
+        > = (state, action) => {
           const newState = reducer(state, action)
           return {
             ...newState,
@@ -268,11 +276,14 @@ function finalHelmersonExample() {
     foo: string
   }
 
-  function persistReducer<S, A extends Action<unknown>>(
+  function persistReducer<S, A extends Action<unknown>, PreloadedState>(
     config: any,
-    reducer: Reducer<S, A>
+    reducer: Reducer<S, A, PreloadedState>
   ) {
-    return (state: (S & ExtraState) | undefined, action: A) => {
+    return (
+      state: (S & ExtraState) | PreloadedState | undefined,
+      action: A
+    ) => {
       const newState = reducer(state, action)
       return {
         ...newState,
@@ -289,11 +300,11 @@ function finalHelmersonExample() {
     persistConfig: any
   ): StoreEnhancer<{}, ExtraState> {
     return createStore =>
-      <S, A extends Action<unknown>>(
-        reducer: Reducer<S, A>,
-        preloadedState?: any
+      <S, A extends Action<unknown>, PreloadedState>(
+        reducer: Reducer<S, A, PreloadedState>,
+        preloadedState?: PreloadedState | undefined
       ) => {
-        const persistedReducer = persistReducer<S, A>(persistConfig, reducer)
+        const persistedReducer = persistReducer(persistConfig, reducer)
         const store = createStore(persistedReducer, preloadedState)
         const persistor = persistStore(store)