@types/prop-types

const any: Requireable<any>;

const array: Requireable<any[]>;

const bool: Requireable<boolean>;

const element: Requireable<ReactElementLike>;

const elementType: Requireable<ReactComponentLike>;

const func: Requireable<(...args: any[]) => any>;

const node: Requireable<ReactNodeLike>;

const nominalTypeHack: Symbol;

const number: Requireable<number>;

const object: Requireable<object>;

const string: Requireable<string>;

const symbol: Requireable<symbol>;

arrayOf: <T>(type: Validator<T>) => Requireable<T[]>;

checkPropTypes: (
    typeSpecs: any,
    values: any,
    location: string,
    componentName: string,
    getStack?: () => any
) => void;

exact: <P extends ValidationMap<any>>(
    type: P
) => Requireable<Required<InferProps<P>>>;

instanceOf: <T>(expectedClass: new (...args: any[]) => T) => Requireable<T>;

objectOf: <T>(type: Validator<T>) => Requireable<{ [x: string]: T }>;

oneOf: <T>(types: readonly T[]) => Requireable<T>;

oneOfType: <T extends Validator<any>>(
    types: T[]
) => Requireable<NonNullable<InferType<T>>>;

resetWarningCache: () => void;

shape: <P extends ValidationMap<any>>(type: P) => Requireable<InferProps<P>>;

type InferProps<V> = InferPropsInner<Pick<V, RequiredKeys<V>>> &
    Partial<InferPropsInner<Pick<V, OptionalKeys<V>>>>;

type InferPropsInner<V> = { [K in keyof V]-?: InferType<V[K]> };

type InferType<V> = V extends Validator<infer T> ? T : any;

type IsOptional<T> = undefined extends T ? true : false;

type OptionalKeys<V> = Exclude<keyof V, RequiredKeys<V>>;

type ReactComponentLike =
    | string
    | ((props: any, context?: any) => any)
    | (new (props: any, context?: any) => any);

type ReactNodeLike =
    | ReactElementLike
    | ReactNodeArray
    | string
    | number
    | boolean
    | null
    | undefined;

type RequiredKeys<V> = {
    [K in keyof V]-?: Exclude<V[K], undefined> extends Validator<infer T>
        ? IsOptional<T> extends true
            ? never
            : K
        : never;
}[keyof V];

type ValidationMap<T> = { [K in keyof T]?: Validator<T[K]> };

type WeakValidationMap<T> = {
    [K in keyof T]?: null extends T[K]
        ? Validator<T[K] | null | undefined>
        : undefined extends T[K]
        ? Validator<T[K] | null | undefined>
        : Validator<T[K]>;
};