如果你正在处理接受不同参数的动作，那么你需要基于这些特定动作的Map来定义你的类型，而不是基于一个模糊的一般化类型。
由于这里只有两个action creator，它们都不接受任何参数（除了dispatch），因此它们都可以用以下类型描述：

(dispatch: React.Dispatch<Action>) => () => void

所以你会

type Actions = Record<string, (dispatch: React.Dispatch<Action>) => () => void>

我仍然不喜欢这个类型，因为它的键类型是string，而不是你的特定操作函数login和logout。但是现在我们已经输入了更好的类型，Typescript可以开始按预期工作，并给我们提供有用的错误。
在函数中创建的boundActions不应该与我们作为参数传递的actions具有相同的类型。actions是接受Dispatch并返回函数() => void的函数。boundActions只是返回函数() => void。
所以我们开始看到你的设计有一些问题。使用未绑定的动作作为上下文的默认值是没有意义的（或者通过类型检查），因为这些动作与它们的绑定版本本质上是不同的。
当您只是将Function用作类型时，这些错误被隐藏了起来，这正是它危险的原因！
你可以为你的AuthContext创建实体类型，而不需要做任何“花哨”的事情。但是你想创建一个支持创建多个不同上下文的工厂。你可以使用很多模糊类型，比如Record和any，而且你不会有任何类型错误。但是当你使用上下文时，你也不会得到很多有用的信息。state上有什么属性？我可以调用什么操作？如果你想创建一个工厂，它知道它正在创建的特定上下文，那么你需要使用更高级的Typescript特性，比如泛型和Map类型。
通用设置

import React, { Reducer, Dispatch as _Dispatch } from 'react';

// Very generalized action type
export type Action = { type: string; payload?: any }

// We are not using specific action types.  So we override the React Dispatch type with one that's not generic
export type Dispatch = _Dispatch<Action>

// 

// Map from action functions of dispatch to their bound versions
type BoundActions<ActionMap> = {
    [K in keyof ActionMap]: ActionMap[K] extends ((dispatch: Dispatch) => infer A) ? A : never
}

// The type for the context depends on the State and the action creators
export type AppContext<State, ActionMap> = {
    state: State;
    actions: BoundActions<ActionMap>;
}

type FullContext<State, ActionMap> = {
    Context: React.Context<AppContext<State, ActionMap>>;
    Provider: React.FC; // Provider does not take any props -- just children
}

const createAuthContext = <
    // type for the state
    State,
    // type for the action map
    ActionMap extends Record<string, (dispatch: Dispatch) => (...args: any[]) => void>>(
        reducer: Reducer<State, Action>,
        actions: ActionMap,
        initialState: State,
        init: () => State = (): State => initialState,
): FullContext<State, ActionMap> => {
    const Context = React.createContext<AppContext<State, ActionMap>>({
        state: { ...initialState },
        actions: Object.fromEntries(
            Object.keys(actions).map(key => (
                [key, () => console.error("cannot call action outside of a context provider")]
            )
            )) as BoundActions<ActionMap>,
    })

    const Provider = ({ children }: { children?: React.ReactNode }) => {
        const [state, dispatch] = React.useReducer(reducer, initialState, init)

        // this is not the most elegant way to handle object mapping, but it always requires some assertion
        // there is already a bindActionCreators function in Redux that does this.
        const boundActions = {} as Record<string, any>
        for (const key in actions) {
            boundActions[key] = actions[key](dispatch)
        }

        return (
            <Context.Provider value={{ state, actions: boundActions as BoundActions<ActionMap> }}>
                {children}
            </Context.Provider>
        )
    }

    return {
        Context,
        Provider,
    }
}

具体实施

export type AuthState = {
    isLogged: boolean;
    avoidLogin: boolean;
}

const authReducer = (state: AuthState, action: Action): AuthState => {
    switch (action.type) {
        case 'login':
            return { ...state, isLogged: true, avoidLogin: false }
        case 'logout':
            return { ...state, isLogged: false, avoidLogin: true }
        default:
            return { ...state }
    }
}

// no type = let it be inferred
const actions = {
    login: (dispatch: Dispatch) => () => {
        dispatch({ type: 'login' })
    },
    logout: (dispatch: Dispatch) => () => {
        dispatch({ type: 'logout' })
    },
}

const initialAuthState: AuthState = {
    isLogged: false,
    avoidLogin: true
}

const { Context: AuthContext, Provider } = createAuthContext(authReducer, actions, initialAuthState);

export function Login(): JSX.Element {
    // this is where the magic happens!
    const {
        // can only destructure known actions, will get errors on typos
        actions: { login },
        state
    } = React.useContext(AuthContext)

    // we now know all the properties of the state and their types
    const { isLogged } = state;

    return (
        <View>
            <Button text='Entrar' onPress={() => login()} />
        </View>
    )
}

Typescript Playground Link

我认为这个例子有助于理解TS中的Record类型。

type AppProps = {
  /** a dictionary object with any number of properties of the same type */
  dict1: {
    [key: string]: MyTypeHere;
  };
  dict2: Record<string, MyTypeHere>; // equivalent to dict1
}