interface ConfigureStoreOptions<
  S = any,
  A extends Action = AnyAction,
  M extends Middlewares<S> = Middlewares<S>
> {
  /**
   * A single reducer function that will be used as the root reducer, or an
   * object of slice reducers that will be passed to `combineReducers()`.
   */
  reducer: Reducer<S, A> | ReducersMapObject<S, A>
  /**
   * An array of Redux middleware to install. If not supplied, defaults to
   * the set of middleware returned by `getDefaultMiddleware()`.
   */
  middleware?: ((getDefaultMiddleware: CurriedGetDefaultMiddleware<S>) => M) | M
  /**
   * Whether to enable Redux DevTools integration. Defaults to `true`.
   *
   * Additional configuration can be done by passing Redux DevTools options
   */
  devTools?: boolean | DevToolsOptions
  /**
   * The initial state, same as Redux's createStore.
   * You may optionally specify it to hydrate the state
   * from the server in universal apps, or to restore a previously serialized
   * user session. If you use `combineReducers()` to produce the root reducer
   * function (either directly or indirectly by passing an object as `reducer`),
   * this must be an object with the same shape as the reducer map keys.
   */
  preloadedState?: DeepPartial<S extends any ? S : S>
  /**
   * The store enhancers to apply. See Redux's `createStore()`.
   * All enhancers will be included before the DevTools Extension enhancer.
   * If you need to customize the order of enhancers, supply a callback
   * function that will receive the original array (ie, `[applyMiddleware]`),
   * and should return a new array (such as `[applyMiddleware, offline]`).
   * If you only need to add middleware, you can use the `middleware` parameter instead.
   */
  enhancers?: StoreEnhancer[] | ConfigureEnhancersCallback
}
function configureStore<S = any, A extends Action = AnyAction>(
  options: ConfigureStoreOptions<S, A>
): EnhancedStore<S, A>

import { configureStore } from '@reduxjs/toolkit'
import logger from 'redux-logger'
import rootReducer from './reducer'
const store = configureStore({
  reducer: rootReducer,
  middleware: (getDefaultMiddleware) => getDefaultMiddleware().concat(logger),
})
// Store has all of the default middleware added, _plus_ the logger middleware

import { createStore } from 'redux'
const store = createStore(todos, ['Use Redux'])
function addTodo(text) {
  return {
    type: 'ADD_TODO',
    text
  }
}
store.dispatch(addTodo('Read the docs'))
store.dispatch(addTodo('Read about the middleware'))

// 常に最新のstateを取得する例
// stateを変更するとsubscribe()の引数に指定されたコールバック関数が実行される
let appState = store.getState();
store.subscribe(() => {appState = store.getState()});

const store = createStore(plusMinus);
store.subscribe(() => console.log(store.getState()));
store.dispatch({type: INCREMENT, amount: 5}); // 5
store.dispatch({type: DECREMENT, amount: 3}); // 2
store.replaceReducer(multiplication); // 2
// reducer が multiplication に変わっているので INCREMENT は実行されず state がそのまま返される
store.dispatch({type: INCREMENT, amount: 4}); // 2
store.dispatch({type: MULTIPLICATION, amount: 3}); // 6

function createSlice({
    //名称（action type に使われる）
    name: string,
    //reducer の初期値
    initialState: any,
    //case reducer たちのオブジェクト
    reducers: Object<string, ReducerFunction | ReducerAndPrepareObject>
    //別で作成しておいた action に対する reducer（任意）
    extraReducers?:
    | Object<string, ReducerFunction>
    | ((builder: ActionReducerMapBuilder<State>) => void)
})

{
    name : string,
    reducer : ReducerFunction,
    actions : Record<string, ActionCreator>,
    caseReducers: Record<string, CaseReducer>
}

const todoSlice = createSlice({
  name: 'todos',
  initialState: [] as Item[],
  reducers: {},
  extraReducers: (builder) => {
    builder
    .addCase(fetchUserById.pending, (state, action) => {
      //非同期処理中のロジック
    })
    .addCase(fetchUserById.fulfilled, (state, action) => {
      //非同期処理成功時のロジック
    })
    .addCase(fetchUserById.rejected, (state, action) => {
      //非同期処理失敗時のロジック
    })
  }
})

interface PayloadAction<P, T extends string, M, E> {
  type: T;
  payload: P;
  meta: M;
  error: E;
}

{
    type: "アクションの種類を一意に識別できる文字列またはシンボル",
    payload: "アクションの実行に必要な任意のデータ",
}

import { configureStore } from '@reduxjs/toolkit'
import counterReducer from '../features/counter/counterSlice'
export default configureStore({
  reducer: {
    counter: counterReducer,
  },
})

const result: any = useSelector(selector: Function, equalityFn?: Function)