@types/prop-types

TypesSource
Search for an npm package
    "@types/prop-types"

@types/prop-types

decl
module "@types/prop-types" {

instanceOf

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

oneOf

decl
export function oneOf<T>(types: readonly T[]): Requireable<T>

oneOfType

decl
export function oneOfType<T extends Validator<any>>(types: T[]): Requireable<NonNullable<InferType<T>>>

arrayOf

decl
export function arrayOf<T>(type: Validator<T>): Requireable<T[]>

objectOf

decl
export function objectOf<T>(type: Validator<T>): Requireable<{
[K in keyof any]: T;
}>

shape

decl
export function shape<P extends ValidationMap<any>>(type: P): Requireable<InferProps<P>>

exact

decl
export function exact<P extends ValidationMap<any>>(type: P): Requireable<Required<InferProps<P>>>

checkPropTypes

decl

Assert that the values match with the type specs. Error messages are memorized and will only be shown once.

more
less

@param — Map of name to a ReactPropType

@param — Runtime values that need to be type-checked

@param — e.g. "prop", "context", "child context"

@param — Name of the component for error messages

@param — Returns the component stack

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

resetWarningCache

decl

Only available if NODE_ENV=production

export function resetWarningCache(): void

ReactComponentLike

decl
export type ReactComponentLike = string | ((props: any, context?: any) => any) | (new (props: any, context?: any) => any)
Referenced by

ReactElementLike

decl
export interface ReactElementLike {
type: ReactComponentLike;
props: any;
key: string | null;
}
Referenced by

ReactNodeArray

decl
export interface ReactNodeArray extends Iterable<ReactNodeLike> {}
Referenced by

ReactNodeLike

decl
export type ReactNodeLike = ReactElementLike | ReactNodeArray | string | number | boolean | null | undefined
Referenced by

nominalTypeHack

decl
export const nominalTypeHack: unique symbol = ...

IsOptional

decl
export type IsOptional<T> = undefined extends T ? true : false
Referenced by

RequiredKeys

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

OptionalKeys

decl
export type OptionalKeys<V> = Exclude<keyof V, RequiredKeys<V>>
Referenced by

InferPropsInner

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

Validator

decl
export interface Validator<T> {
(props: {
[key: string]: any;
}, propName: string, componentName: string, location: string, propFullName: string): Error | null;
[nominalTypeHack]?: {
type: T;
} | undefined;
}
Referenced by

Requireable

decl
export interface Requireable<T> extends Validator<T | undefined | null> {
isRequired: Validator<NonNullable<T>>;
}
Referenced by

ValidationMap

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

WeakValidationMap

decl

Like ValidationMap but treats undefined, null and optional properties the same. This type is only added as a migration path in React 19 where this type was removed from React. Runtime and compile time types would mismatch since you could see undefined at runtime when your types don't expect this type.

export 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]>;
}

InferType

decl
export type InferType<V> = V extends Validator<infer T> ? T : any
Referenced by

InferProps

decl
export type InferProps<V> = InferPropsInner<Pick<V, RequiredKeys<V>>> & Partial<InferPropsInner<Pick<V, OptionalKeys<V>>>>
Referenced by

any

decl
export const any: Requireable<any> = ...

array

decl
export const array: Requireable<any[]> = ...

bool

decl
export const bool: Requireable<boolean> = ...

func

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

number

decl
export const number: Requireable<number> = ...

object

decl
export const object: Requireable<object> = ...

string

decl
export const string: Requireable<string> = ...

node

decl
export const node: Requireable<ReactNodeLike> = ...

element

decl
export const element: Requireable<ReactElementLike> = ...

symbol

decl
export const symbol: Requireable<symbol> = ...

elementType

decl
export const elementType: Requireable<ReactComponentLike> = ...
}