typesafe-actions

const deprecated: {
    createAction: typeof createAction;
    createCustomAction: typeof createCustomAction;
    createStandardAction: typeof createStandardAction;
};

action: {
    <T extends string, E>(type: T, payload: undefined, meta: undefined, error: E): {
        type: T;
        error: E;
    };
    <T extends string, M, E>(type: T, payload: undefined, meta: M, error: E): {
        type: T;
        meta: M;
        error: E;
    };
    <T extends string, P, E>(type: T, payload: P, meta: undefined, error: E): {
        type: T;
        payload: P;
        error: E;
    };
    <T extends string, P, M, E>(type: T, payload: P, meta: M, error: E): {
        type: T;
        payload: P;
        meta: M;
        error: E;
    };
    <T extends string, M>(type: T, payload: undefined, meta: M): {
        type: T;
        meta: M;
    };
    <T extends string, P, M>(type: T, payload: P, meta: M): {
        type: T;
        payload: P;
        meta: M;
    };
    <T extends string, P>(type: T, payload: P): { type: T; payload: P };
    <T extends string>(type: T): { type: T };
};

createAction: {
    <TType extends string>(type: TType): <
        TPayload = undefined,
        TMeta = undefined
    >() => ActionCreatorBuilder<TType, TPayload, TMeta>;
    <
        TType extends string,
        TCreatorPayload extends unknown = undefined,
        TCreatorMeta extends unknown = undefined,
        TArgs extends any[] = any[]
    >(
        type: TType,
        payloadCreator: (...args: TArgs) => TCreatorPayload,
        metaCreator?: (...args: TArgs) => TCreatorMeta
    ): <
        TPayload extends TCreatorPayload = TCreatorPayload,
        TMeta extends TCreatorMeta = TCreatorMeta
    >() => (...args: TArgs) => ActionBuilder<TType, TPayload, TMeta>;
};

createAsyncAction: {
    <
        TType1 extends string,
        TType2 extends string,
        TType3 extends string,
        TType4 extends string = never
    >(
        requestArg: TType1,
        successArg: TType2,
        failureArg: TType3,
        cancelArg?: TType4
    ): AsyncAction<
        TType1,
        unknown,
        unknown,
        never,
        TType2,
        unknown,
        unknown,
        never,
        TType3,
        unknown,
        unknown,
        never,
        TType4,
        unknown,
        unknown,
        never
    >;
    <
        TType1 extends string,
        TType2 extends string,
        TType3 extends string,
        TType4 extends string = never,
        TPayloadCreator1 extends (...args: TArgs1) => TPayload1 = undefined,
        TPayloadCreator2 extends (...args: TArgs2) => TPayload2 = undefined,
        TPayloadCreator3 extends (...args: TArgs3) => TPayload3 = undefined,
        TPayloadCreator4 extends (...args: TArgs4) => TPayload4 = undefined,
        TMetaCreator1 extends (...args: TArgs1) => TMeta1 = undefined,
        TMetaCreator2 extends (...args: TArgs2) => TMeta2 = undefined,
        TMetaCreator3 extends (...args: TArgs3) => TMeta3 = undefined,
        TMetaCreator4 extends (...args: TArgs4) => TMeta4 = undefined,
        TPayload1 extends unknown = TPayloadCreator1 extends (
            ...args: any[]
        ) => infer T
            ? T
            : undefined,
        TMeta1 extends unknown = TMetaCreator1 extends (...args: any[]) => infer T
            ? T
            : undefined,
        TPayload2 extends unknown = TPayloadCreator2 extends (
            ...args: any[]
        ) => infer T
            ? T
            : undefined,
        TMeta2 extends unknown = TMetaCreator2 extends (...args: any[]) => infer T
            ? T
            : undefined,
        TPayload3 extends unknown = TPayloadCreator3 extends (
            ...args: any[]
        ) => infer T
            ? T
            : undefined,
        TMeta3 extends unknown = TMetaCreator3 extends (...args: any[]) => infer T
            ? T
            : undefined,
        TPayload4 extends unknown = TPayloadCreator4 extends (
            ...args: any[]
        ) => infer T
            ? T
            : undefined,
        TMeta4 extends unknown = TMetaCreator4 extends (...args: any[]) => infer T
            ? T
            : undefined,
        TArgs1 extends any[] = TPayloadCreator1 extends (...args: infer T) => any
            ? T
            : TMetaCreator1 extends (...args: infer T) => any
            ? T
            : never,
        TArgs2 extends any[] = TPayloadCreator2 extends (...args: infer T) => any
            ? T
            : TMetaCreator2 extends (...args: infer T) => any
            ? T
            : never,
        TArgs3 extends any[] = TPayloadCreator3 extends (...args: infer T) => any
            ? T
            : TMetaCreator3 extends (...args: infer T) => any
            ? T
            : never,
        TArgs4 extends any[] = TPayloadCreator4 extends (...args: infer T) => any
            ? T
            : TMetaCreator4 extends (...args: infer T) => any
            ? T
            : never
    >(
        requestArg:
            | TType1
            | [TType1, TPayloadCreator1]
            | [TType1, TPayloadCreator1, TMetaCreator1],
        successArg:
            | TType2
            | [TType2, TPayloadCreator2]
            | [TType2, TPayloadCreator2, TMetaCreator2],
        failureArg:
            | TType3
            | [TType3, TPayloadCreator3]
            | [TType3, TPayloadCreator3, TMetaCreator3],
        cancelArg?:
            | TType4
            | [TType4, TPayloadCreator4]
            | [TType4, TPayloadCreator4, TMetaCreator4]
    ): AsyncAction<
        TType1,
        TPayload1,
        TMeta1,
        TArgs1,
        TType2,
        TPayload2,
        TMeta2,
        TArgs2,
        TType3,
        TPayload3,
        TMeta3,
        TArgs3,
        TType4,
        TPayload4,
        TMeta4,
        TArgs4
    >;
};

createCustomAction: <
    TType extends string,
    TArgs extends any[] = [],
    TReturn extends unknown = {}
>(
    type: TType,
    createHandler?: (...args: TArgs) => TReturn
) => ((...args: TArgs) => ResolveType<{ type: TType } & TReturn>) &
    ActionCreatorTypeMetadata<TType>;

createReducer: <TState, TRootAction extends Action<string> = any>(
    initialState: TState,
    initialHandlers?: InitialHandler<TState, TRootAction>
) => Reducer<TState, TRootAction> &
    Readonly<{
        handlers: InitialHandler<TState, any>;
        handleAction: [unknown] extends [TRootAction]
            ? any
            : HandleActionChainApi<TState, TRootAction, TRootAction>;
        handleType: [unknown] extends [TRootAction]
            ? any
            : HandleTypeChainApi<TState, TRootAction, TRootAction>;
    }>;

getType: <TType extends string>(
    actionCreator: ActionCreator<TType> & ActionCreatorTypeMetadata<TType>
) => TType;

isActionOf: {
    <AC extends ActionCreator<{ type: string }>>(
        actionCreator: AC | AC[],
        action: { type: string }
    ): action is ReturnType<AC>;
    <AC extends ActionCreator<{ type: string }>>(
        actionCreator: AC | AC[]
    ): (action: { type: string }) => action is ReturnType<AC>;
};

isOfType: {
    <T extends string, A extends { type: string }>(
        type: T | T[],
        action: A
    ): action is A extends { type: T } ? A : never;
    <T extends string>(type: T | T[]): <A extends { type: string }>(
        action: A
    ) => action is A extends { type: T } ? A : never;
};

type Action<TType extends TypeConstant = TypeConstant> = {
    type: TType;
};

type ActionBuilder<
    TType extends TypeConstant,
    TPayload extends any = undefined,
    TMeta extends any = undefined
> = [TMeta] extends [undefined]
    ? [TPayload] extends [undefined]
        ? unknown extends TPayload
            ? PayloadAction<TType, TPayload>
            : unknown extends TMeta
            ? PayloadMetaAction<TType, TPayload, TMeta>
            : EmptyAction<TType>
        : PayloadAction<TType, TPayload>
    : PayloadMetaAction<TType, TPayload, TMeta>;

type ActionCreator<TType extends TypeConstant = TypeConstant> = (
    ...args: any[]
) => Action<TType>;

type ActionCreatorBuilder<
    TType extends TypeConstant,
    TPayload extends any = undefined,
    TMeta extends any = undefined
> = [TMeta] extends [undefined]
    ? [TPayload] extends [undefined]
        ? unknown extends TPayload
            ? PayloadActionCreator<TType, TPayload>
            : unknown extends TMeta
            ? PayloadMetaActionCreator<TType, TPayload, TMeta>
            : EmptyActionCreator<TType>
        : PayloadActionCreator<TType, TPayload>
    : PayloadMetaActionCreator<TType, TPayload, TMeta>;

type ActionType<TActionCreatorOrMap extends any> =
    TActionCreatorOrMap extends ActionCreator<TypeConstant>
        ? ReturnType<TActionCreatorOrMap>
        : TActionCreatorOrMap extends Record<any, any>
        ? {
              [K in keyof TActionCreatorOrMap]: ActionType<TActionCreatorOrMap[K]>;
          }[keyof TActionCreatorOrMap]
        : TActionCreatorOrMap extends infer R
        ? never
        : never;

type AsyncActionCreatorBuilder<
    TRequest extends
        | [TType1, TPayload1]
        | [TType1, [TPayload1, TMeta1]]
        | [TType1, TArgs1, TPayload1]
        | [TType1, TArgs1, [TPayload1, TMeta1]],
    TSuccess extends
        | [TType2, TPayload2]
        | [TType2, [TPayload2, TMeta2]]
        | [TType2, TArgs2, TPayload2]
        | [TType2, TArgs2, [TPayload2, TMeta2]],
    TFailure extends
        | [TType3, TPayload3]
        | [TType3, [TPayload3, TMeta3]]
        | [TType3, TArgs3, TPayload3]
        | [TType3, TArgs3, [TPayload3, TMeta3]],
    TCancel extends
        | [TType4, TPayload4]
        | [TType4, [TPayload4, TMeta4]]
        | [TType4, TArgs4, TPayload4]
        | [TType4, TArgs4, [TPayload4, TMeta4]] = never,
    TType1 extends TypeConstant = TRequest[0],
    TPayload1 = TRequest extends [TType1, any, [any, any]]
        ? TRequest[2][0]
        : TRequest extends [TType1, any, any]
        ? TRequest[2]
        : TRequest extends [TType1, [any, any]]
        ? TRequest[1][0]
        : TRequest[1],
    TMeta1 = TRequest extends [TType1, any, [any, any]]
        ? TRequest[2][1]
        : TRequest extends [TType1, [any, any]]
        ? TRequest[1][1]
        : never,
    TArgs1 extends any[] = TRequest extends [TType1, any, any] ? TRequest[1] : never,
    TType2 extends TypeConstant = TSuccess[0],
    TPayload2 = TSuccess extends [TType2, any, [any, any]]
        ? TSuccess[2][0]
        : TSuccess extends [TType2, any, any]
        ? TSuccess[2]
        : TSuccess extends [TType2, [any, any]]
        ? TSuccess[1][0]
        : TSuccess[1],
    TMeta2 = TSuccess extends [TType2, any, [any, any]]
        ? TSuccess[2][1]
        : TSuccess extends [TType2, [any, any]]
        ? TSuccess[1][1]
        : never,
    TArgs2 extends any[] = TSuccess extends [TType2, any, any] ? TSuccess[1] : never,
    TType3 extends TypeConstant = TFailure[0],
    TPayload3 = TFailure extends [TType3, any, [any, any]]
        ? TFailure[2][0]
        : TFailure extends [TType3, any, any]
        ? TFailure[2]
        : TFailure extends [TType3, [any, any]]
        ? TFailure[1][0]
        : TFailure[1],
    TMeta3 = TFailure extends [TType3, any, [any, any]]
        ? TFailure[2][1]
        : TFailure extends [TType3, [any, any]]
        ? TFailure[1][1]
        : never,
    TArgs3 extends any[] = TFailure extends [TType3, any, any] ? TFailure[1] : never,
    TType4 extends TypeConstant = TCancel[0],
    TPayload4 = TCancel extends [TType4, any, [any, any]]
        ? TCancel[2][0]
        : TCancel extends [TType4, any, any]
        ? TCancel[2]
        : TCancel extends [TType4, [any, any]]
        ? TCancel[1][0]
        : TCancel[1],
    TMeta4 = TCancel extends [TType4, any, [any, any]]
        ? TCancel[2][1]
        : TCancel extends [TType4, [any, any]]
        ? TCancel[1][1]
        : never,
    TArgs4 extends any[] = TCancel extends [TType4, any, any] ? TCancel[1] : never
> = [TCancel] extends [never]
    ? {
          request: [TArgs1] extends [never]
              ? ActionCreatorBuilder<TType1, TPayload1, TMeta1>
              : (...args: TArgs1) => ActionBuilder<TType1, TPayload1, TMeta1>;
          success: [TArgs2] extends [never]
              ? ActionCreatorBuilder<TType2, TPayload2, TMeta2>
              : (...args: TArgs2) => ActionBuilder<TType2, TPayload2, TMeta2>;
          failure: [TArgs3] extends [never]
              ? ActionCreatorBuilder<TType3, TPayload3, TMeta3>
              : (...args: TArgs3) => ActionBuilder<TType3, TPayload3, TMeta3>;
      }
    : {
          request: [TArgs1] extends [never]
              ? ActionCreatorBuilder<TType1, TPayload1, TMeta1>
              : (...args: TArgs1) => ActionBuilder<TType1, TPayload1, TMeta1>;
          success: [TArgs2] extends [never]
              ? ActionCreatorBuilder<TType2, TPayload2, TMeta2>
              : (...args: TArgs2) => ActionBuilder<TType2, TPayload2, TMeta2>;
          failure: [TArgs3] extends [never]
              ? ActionCreatorBuilder<TType3, TPayload3, TMeta3>
              : (...args: TArgs3) => ActionBuilder<TType3, TPayload3, TMeta3>;
          cancel: [TArgs4] extends [never]
              ? ActionCreatorBuilder<TType4, TPayload4, TMeta4>
              : (...args: TArgs4) => ActionBuilder<TType4, TPayload4, TMeta4>;
      };

type EmptyAction<TType extends TypeConstant> = {
    type: TType;
};

type EmptyActionCreator<TType extends TypeConstant> = () => EmptyAction<TType>;

type PayloadAction<TType extends TypeConstant, TPayload> = {
    type: TType;
    payload: TPayload;
};

type PayloadActionCreator<TType extends TypeConstant, TPayload> = (
    payload: TPayload
) => PayloadAction<TType, TPayload>;

type PayloadMetaAction<TType extends TypeConstant, TPayload, TMeta> = {
    type: TType;
    payload: TPayload;
    meta: TMeta;
};

type PayloadMetaActionCreator<TType extends TypeConstant, TPayload, TMeta> = (
    payload: TPayload,
    meta: TMeta
) => PayloadMetaAction<TType, TPayload, TMeta>;

type Reducer<TState, TAction extends Action> = (
    state: TState | undefined,
    action: TAction
) => TState;

type StateType<TReducerOrMap extends any> = TReducerOrMap extends Reducer<any, any>
    ? ReturnType<TReducerOrMap>
    : TReducerOrMap extends Record<any, any>
    ? {
          [K in keyof TReducerOrMap]: StateType<TReducerOrMap[K]>;
      }
    : never;

type TypeConstant = string;