Prevent inference of any in create.asyncThunk

Author: EskiMojo14

Diff for: packages/toolkit/src/createSlice.ts

@@ -427,15 +427,7 @@ export interface ReducerCreators<State> {
  * @public
  */
 export type SliceCaseReducers<State> =
-  | Record<
-      string,
-      | CaseReducerDefinition<State, PayloadAction<any>>
-      | CaseReducerWithPrepareDefinition<
-          State,
-          PayloadAction<any, string, any, any>
-        >
-      | AsyncThunkSliceReducerDefinition<State, any, any, any>
-    >
+  | Record<string, ReducerDefinition>
   | Record<
       string,
       | CaseReducer<State, PayloadAction<any>>
@@ -692,7 +684,7 @@ export function buildCreateSlice({ creators }: BuildCreateSliceConfig = {}) {
       } else {
         handleNormalReducerDefinition<State>(
           reducerDetails,
-          reducerDefinition,
+          reducerDefinition as any,
           contextMethods,
         )
       }

Diff for: packages/toolkit/src/tests/createSlice.test-d.ts

@@ -652,6 +652,38 @@ describe('type tests', () => {
               expectTypeOf(action.error).toEqualTypeOf<'error'>()
             },
           ),
+          testInferVoid: create.asyncThunk(() => {}, {
+            pending(state, action) {
+              expectTypeOf(state).toEqualTypeOf<TestState>()
+
+              expectTypeOf(action.meta.arg).toBeVoid()
+            },
+            fulfilled(state, action) {
+              expectTypeOf(state).toEqualTypeOf<TestState>()
+
+              expectTypeOf(action.meta.arg).toBeVoid()
+
+              expectTypeOf(action.payload).toBeVoid()
+            },
+            rejected(state, action) {
+              expectTypeOf(state).toEqualTypeOf<TestState>()
+
+              expectTypeOf(action.meta.arg).toBeVoid()
+
+              expectTypeOf(action.error).toEqualTypeOf<SerializedError>()
+            },
+            settled(state, action) {
+              expectTypeOf(state).toEqualTypeOf<TestState>()
+
+              expectTypeOf(action.meta.arg).toBeVoid()
+
+              if (isRejected(action)) {
+                expectTypeOf(action.error).toEqualTypeOf<SerializedError>()
+              } else {
+                expectTypeOf(action.payload).toBeVoid()
+              }
+            },
+          }),
           testInfer: create.asyncThunk(
             function payloadCreator(arg: TestArg, api) {
               return Promise.resolve<TestReturned>({ payload: 'foo' })
@@ -856,6 +888,12 @@ describe('type tests', () => {
       >
     >()
 
+    expectTypeOf(slice.actions.testInferVoid).toEqualTypeOf<
+      AsyncThunk<void, void, {}>
+    >()
+
+    expectTypeOf(slice.actions.testInferVoid).toBeCallableWith()
+
     expectTypeOf(slice.actions.testInfer).toEqualTypeOf<
       AsyncThunk<TestReturned, TestArg, {}>
     >()