react-redux

const batch: (callback: () => void) => void;

const connect: Connect<unknown>;

const FORWARD_REF_STATICS: {
    readonly $$typeof: true;
    readonly render: true;
    readonly defaultProps: true;
    readonly displayName: true;
    readonly propTypes: true;
};

const KNOWN_STATICS: {
    readonly name: true;
    readonly length: true;
    readonly prototype: true;
    readonly caller: true;
    readonly callee: true;
    readonly arguments: true;
    readonly arity: true;
};

const legacy_connect: Connect<unknown>;

const MEMO_STATICS: {
    readonly $$typeof: true;
    readonly compare: true;
    readonly defaultProps: true;
    readonly displayName: true;
    readonly propTypes: true;
    readonly type: true;
};

const REACT_STATICS: {
    readonly childContextTypes: true;
    readonly contextType: true;
    readonly contextTypes: true;
    readonly defaultProps: true;
    readonly displayName: true;
    readonly getDefaultProps: true;
    readonly getDerivedStateFromError: true;
    readonly getDerivedStateFromProps: true;
    readonly mixins: true;
    readonly propTypes: true;
    readonly type: true;
};

const ReactReduxContext: Context<ReactReduxContextValue<any, UnknownAction>>;

const useDispatch: UseDispatch<Dispatch<UnknownAction>>;

const useSelector: UseSelector<unknown>;

const useStore: UseStore<Store<unknown, Action, unknown>>;

createDispatchHook: <
    StateType = unknown,
    ActionType extends Action = UnknownAction
>(
    context?: Context<ReactReduxContextValue<StateType, ActionType>>
) => UseDispatch<Dispatch<ActionType>>;

createListenerCollection: () => {
    clear(): void;
    notify(): void;
    get(): Listener[];
    subscribe(callback: () => void): () => void;
};

createSelectorHook: (
    context?: React.Context<ReactReduxContextValue<any, any>>
) => UseSelector;

createStoreHook: <StateType = unknown, ActionType extends Action = Action>(
    context?: Context<ReactReduxContextValue<StateType, ActionType>>
) => UseStore<Store<StateType, ActionType>>;

defaultNoopBatch: (callback: () => void) => void;

Provider: <A extends Action<string> = UnknownAction, S = unknown>(
    providerProps: ProviderProps<A, S>
) => React.JSX.Element;

shallowEqual: (objA: any, objB: any) => boolean;

type AnyIfEmpty<T extends object> = keyof T extends never ? any : T;

type ConnectedComponent<C extends ComponentType<any>, P> = FunctionComponent<P> &
    NonReactStatics<C> & {
        WrappedComponent: C;
    };

type ConnectedProps<TConnector> =
    TConnector extends InferableComponentEnhancerWithProps<infer TInjectedProps, any>
        ? unknown extends TInjectedProps
            ? TConnector extends InferableComponentEnhancer<infer TInjectedProps>
                ? TInjectedProps
                : never
            : TInjectedProps
        : never;

type ConnectPropsMaybeWithoutContext<TActualOwnProps> = TActualOwnProps extends {
    context: any;
}
    ? Omit<ConnectProps, 'context'>
    : ConnectProps;

type DistributiveOmit<T, K extends keyof T> = T extends unknown ? Omit<T, K> : never;

type EqualityFn<T> = (a: T, b: T) => boolean;

type ExtendedEqualityFn<T, P> = (a: T, b: T, c: P, d: P) => boolean;

type FixTypeLater = any;

type GetLibraryManagedProps<C> = JSX.LibraryManagedAttributes<C, GetProps<C>>;

type GetProps<C> = C extends ComponentType<infer P>
    ? C extends ComponentClass<P>
        ? ClassAttributes<InstanceType<C>> & P
        : P
    : never;

type HandleThunkActionCreator<TActionCreator> = TActionCreator extends (
    ...args: any[]
) => any
    ? InferThunkActionCreatorType<TActionCreator>
    : TActionCreator;

type InferableComponentEnhancer<TInjectedProps> =
    InferableComponentEnhancerWithProps<TInjectedProps, {}>;

type InferableComponentEnhancerWithProps<TInjectedProps, TNeedsProps> = <
    C extends ComponentType<Matching<TInjectedProps, GetProps<C>>>
>(
    component: C
) => ConnectedComponent<
    C,
    Mapped<
        DistributiveOmit<
            GetLibraryManagedProps<C>,
            keyof Shared<TInjectedProps, GetLibraryManagedProps<C>>
        > &
            TNeedsProps &
            ConnectPropsMaybeWithoutContext<TNeedsProps & GetProps<C>>
    >
>;

type InferThunkActionCreatorType<TActionCreator extends (...args: any[]) => any> =
    TActionCreator extends (
        ...args: infer TParams
    ) => (...args: any[]) => infer TReturn
        ? (...args: TParams) => TReturn
        : TActionCreator;

type MapDispatchToProps<TDispatchProps, TOwnProps> =
    | MapDispatchToPropsFunction<TDispatchProps, TOwnProps>
    | TDispatchProps;

type MapDispatchToPropsFactory<TDispatchProps, TOwnProps> = (
    dispatch: Dispatch<Action<string>>,
    ownProps: TOwnProps
) => MapDispatchToPropsFunction<TDispatchProps, TOwnProps>;

type MapDispatchToPropsFunction<TDispatchProps, TOwnProps> = (
    dispatch: Dispatch<Action<string>>,
    ownProps: TOwnProps
) => TDispatchProps;

type MapDispatchToPropsNonObject<TDispatchProps, TOwnProps> =
    | MapDispatchToPropsFactory<TDispatchProps, TOwnProps>
    | MapDispatchToPropsFunction<TDispatchProps, TOwnProps>;

type MapDispatchToPropsParam<TDispatchProps, TOwnProps> =
    | MapDispatchToPropsFactory<TDispatchProps, TOwnProps>
    | MapDispatchToProps<TDispatchProps, TOwnProps>;

type Mapped<T> = Identity<{
    [k in keyof T]: T[k];
}>;

type MapStateToProps<TStateProps, TOwnProps, State> = (
    state: State,
    ownProps: TOwnProps
) => TStateProps;

type MapStateToPropsFactory<TStateProps, TOwnProps, State> = (
    initialState: State,
    ownProps: TOwnProps
) => MapStateToProps<TStateProps, TOwnProps, State>;

type MapStateToPropsParam<TStateProps, TOwnProps, State> =
    | MapStateToPropsFactory<TStateProps, TOwnProps, State>
    | MapStateToProps<TStateProps, TOwnProps, State>
    | null
    | undefined;

type Matching<InjectedProps, DecorationTargetProps> = {
    [P in keyof DecorationTargetProps]: P extends keyof InjectedProps
        ? InjectedProps[P] extends DecorationTargetProps[P]
            ? DecorationTargetProps[P]
            : InjectedProps[P]
        : DecorationTargetProps[P];
};

type MergeProps<TStateProps, TDispatchProps, TOwnProps, TMergedProps> = (
    stateProps: TStateProps,
    dispatchProps: TDispatchProps,
    ownProps: TOwnProps
) => TMergedProps;

type NoInfer<T> = [T][T extends any ? 0 : never];

type ResolveThunks<TDispatchProps> = TDispatchProps extends {
    [key: string]: any;
}
    ? {
          [C in keyof TDispatchProps]: HandleThunkActionCreator<TDispatchProps[C]>;
      }
    : TDispatchProps;

type Selector<S, TProps, TOwnProps = null> = TOwnProps extends null | undefined
    ? (state: S) => TProps
    : (state: S, ownProps: TOwnProps) => TProps;

type SelectorFactory<S, TProps, TOwnProps, TFactoryOptions> = (
    dispatch: Dispatch<Action<string>>,
    factoryOptions: TFactoryOptions
) => Selector<S, TProps, TOwnProps>;

type Shared<InjectedProps, DecorationTargetProps> = {
    [P in Extract<
        keyof InjectedProps,
        keyof DecorationTargetProps
    >]?: InjectedProps[P] extends DecorationTargetProps[P]
        ? DecorationTargetProps[P]
        : never;
};