@types/react

TypesSource
Search for an npm package

@types/react

decl
module "@types/react" {

createFactory

decldecldecldecldecldecldecl
export function createFactory<T extends HTMLElement>(type: keyof ReactHTML): HTMLFactory<T>
export function createFactory(type: keyof ReactSVG): SVGFactory
export function createFactory<P extends DOMAttributes<T>, T extends Element>(type: string): DOMFactory<P, T>
export function createFactory<P>(type: FunctionComponent<P>): FunctionComponentFactory<P>
export function createFactory<P>(type: ClassType<P, ClassicComponent<P, ComponentState>, ClassicComponentClass<P>>): CFactory<P, ClassicComponent<P, ComponentState>>
export function createFactory<P, T extends Component<P, ComponentState>, C extends ComponentClass<P>>(type: ClassType<P, T, C>): CFactory<P, T>
export function createFactory<P>(type: ComponentClass<P>): Factory<P>

createElement

decldecldecldecldecldecldecldecl
export function createElement(type: "input", props?: InputHTMLAttributes<HTMLInputElement> & ClassAttributes<HTMLInputElement> | null, ...children: ReactNode[]): DetailedReactHTMLElement<InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>
export function createElement<P extends HTMLAttributes<T>, T extends HTMLElement>(type: keyof ReactHTML, props?: ClassAttributes<T> & P | null, ...children: ReactNode[]): DetailedReactHTMLElement<P, T>
export function createElement<P extends SVGAttributes<T>, T extends SVGElement>(type: keyof ReactSVG, props?: ClassAttributes<T> & P | null, ...children: ReactNode[]): ReactSVGElement
export function createElement<P extends DOMAttributes<T>, T extends Element>(type: string, props?: ClassAttributes<T> & P | null, ...children: ReactNode[]): DOMElement<P, T>
export function createElement<P extends {}>(type: FunctionComponent<P>, props?: Attributes & P | null, ...children: ReactNode[]): FunctionComponentElement<P>
export function createElement<P extends {}>(type: ClassType<P, ClassicComponent<P, ComponentState>, ClassicComponentClass<P>>, props?: ClassAttributes<ClassicComponent<P, ComponentState>> & P | null, ...children: ReactNode[]): CElement<P, ClassicComponent<P, ComponentState>>
export function createElement<P extends {}, T extends Component<P, ComponentState>, C extends ComponentClass<P>>(type: ClassType<P, T, C>, props?: ClassAttributes<T> & P | null, ...children: ReactNode[]): CElement<P, T>
export function createElement<P extends {}>(type: FunctionComponent<P> | ComponentClass<P> | string, props?: Attributes & P | null, ...children: ReactNode[]): ReactElement<P>

cloneElement

decldecldecldecldecldecldecl
export function cloneElement<P extends HTMLAttributes<T>, T extends HTMLElement>(element: DetailedReactHTMLElement<P, T>, props?: P, ...children: ReactNode[]): DetailedReactHTMLElement<P, T>
export function cloneElement<P extends HTMLAttributes<T>, T extends HTMLElement>(element: ReactHTMLElement<T>, props?: P, ...children: ReactNode[]): ReactHTMLElement<T>
export function cloneElement<P extends SVGAttributes<T>, T extends SVGElement>(element: ReactSVGElement, props?: P, ...children: ReactNode[]): ReactSVGElement
export function cloneElement<P extends DOMAttributes<T>, T extends Element>(element: DOMElement<P, T>, props?: DOMAttributes<T> & P, ...children: ReactNode[]): DOMElement<P, T>
export function cloneElement<P>(element: FunctionComponentElement<P>, props?: Partial<P> & Attributes, ...children: ReactNode[]): FunctionComponentElement<P>
export function cloneElement<P, T extends Component<P, ComponentState>>(element: CElement<P, T>, props?: Partial<P> & ClassAttributes<T>, ...children: ReactNode[]): CElement<P, T>
export function cloneElement<P>(element: ReactElement<P>, props?: Partial<P> & Attributes, ...children: ReactNode[]): ReactElement<P>

createContext

decl
export function createContext<T>(defaultValue: T): Context<T>

isValidElement

decl
export function isValidElement<P>(object: {} | null | undefined): object is ReactElement<P>

createRef

decl
export function createRef<T>(): RefObject<T>

forwardRef

decl
export function forwardRef<T, P = {}>(render: ForwardRefRenderFunction<T, P>): ForwardRefExoticComponent<PropsWithoutRef<P> & RefAttributes<T>>

memo

decldecl
export function memo<P extends object>(Component: FunctionComponent<P>, propsAreEqual?: (prevProps: Readonly<P>, nextProps: Readonly<P>) => boolean): NamedExoticComponent<P>
export function memo<T extends ComponentType<any>>(Component: T, propsAreEqual?: (prevProps: Readonly<ComponentProps<T>>, nextProps: Readonly<ComponentProps<T>>) => boolean): MemoExoticComponent<T>

lazy

decl
export function lazy<T extends ComponentType<any>>(factory: () => Promise<{
default: T;
}>): LazyExoticComponent<T>

useContext

decl

Accepts a context object (the value returned from React.createContext) and returns the current context value, as given by the nearest context provider for the given context.

more
less

@version — 16.8.0

@see — ://react.dev/reference/react/useContext

export function useContext<T>(context: Context<T>): T

useState

decldecl

Returns a stateful value, and a function to update it.

more
less

@version — 16.8.0

@see — ://react.dev/reference/react/useState

export function useState<S>(initialState: S | (() => S)): [S, Dispatch<SetStateAction<S>>]

Returns a stateful value, and a function to update it.

more
less

@version — 16.8.0

@see — ://react.dev/reference/react/useState

export function useState<S = undefined>(): [S | undefined, Dispatch<SetStateAction<S | undefined>>]

useReducer

decldecldecldecldecl

An alternative to useState.

more
less

useReducer is usually preferable to useState when you have complex state logic that involves multiple sub-values. It also lets you optimize performance for components that trigger deep updates because you can pass dispatch down instead of callbacks.

@version — 16.8.0

@see — ://react.dev/reference/react/useReducer

export function useReducer<R extends ReducerWithoutAction<any>, I>(reducer: R, initializerArg: I, initializer: (arg: I) => ReducerStateWithoutAction<R>): [ReducerStateWithoutAction<R>, DispatchWithoutAction]

An alternative to useState.

more
less

useReducer is usually preferable to useState when you have complex state logic that involves multiple sub-values. It also lets you optimize performance for components that trigger deep updates because you can pass dispatch down instead of callbacks.

@version — 16.8.0

@see — ://react.dev/reference/react/useReducer

export function useReducer<R extends ReducerWithoutAction<any>>(reducer: R, initializerArg: ReducerStateWithoutAction<R>, initializer?: undefined): [ReducerStateWithoutAction<R>, DispatchWithoutAction]

An alternative to useState.

more
less

useReducer is usually preferable to useState when you have complex state logic that involves multiple sub-values. It also lets you optimize performance for components that trigger deep updates because you can pass dispatch down instead of callbacks.

@version — 16.8.0

@see — ://react.dev/reference/react/useReducer

export function useReducer<R extends Reducer<any, any>, I>(reducer: R, initializerArg: I & ReducerState<R>, initializer: (arg: I & ReducerState<R>) => ReducerState<R>): [ReducerState<R>, Dispatch<ReducerAction<R>>]

An alternative to useState.

more
less

useReducer is usually preferable to useState when you have complex state logic that involves multiple sub-values. It also lets you optimize performance for components that trigger deep updates because you can pass dispatch down instead of callbacks.

@version — 16.8.0

@see — ://react.dev/reference/react/useReducer

export function useReducer<R extends Reducer<any, any>, I>(reducer: R, initializerArg: I, initializer: (arg: I) => ReducerState<R>): [ReducerState<R>, Dispatch<ReducerAction<R>>]

An alternative to useState.

more
less

useReducer is usually preferable to useState when you have complex state logic that involves multiple sub-values. It also lets you optimize performance for components that trigger deep updates because you can pass dispatch down instead of callbacks.

@version — 16.8.0

@see — ://react.dev/reference/react/useReducer

export function useReducer<R extends Reducer<any, any>>(reducer: R, initialState: ReducerState<R>, initializer?: undefined): [ReducerState<R>, Dispatch<ReducerAction<R>>]

useRef

decldecldecl

useRef returns a mutable ref object whose .current property is initialized to the passed argument (initialValue). The returned object will persist for the full lifetime of the component.

more
less

Note that useRef() is useful for more than the ref attribute. It’s handy for keeping any mutable value around similar to how you’d use instance fields in classes.

@version — 16.8.0

@see — ://react.dev/reference/react/useRef

export function useRef<T>(initialValue: T): MutableRefObject<T>

useRef returns a mutable ref object whose .current property is initialized to the passed argument (initialValue). The returned object will persist for the full lifetime of the component.

more
less

Note that useRef() is useful for more than the ref attribute. It’s handy for keeping any mutable value around similar to how you’d use instance fields in classes.

Usage note: if you need the result of useRef to be directly mutable, include | null in the type of the generic argument.

@version — 16.8.0

@see — ://react.dev/reference/react/useRef

export function useRef<T>(initialValue: T | null): RefObject<T>

useRef returns a mutable ref object whose .current property is initialized to the passed argument (initialValue). The returned object will persist for the full lifetime of the component.

more
less

Note that useRef() is useful for more than the ref attribute. It’s handy for keeping any mutable value around similar to how you’d use instance fields in classes.

@version — 16.8.0

@see — ://react.dev/reference/react/useRef

export function useRef<T = undefined>(): MutableRefObject<T | undefined>

useLayoutEffect

decl

The signature is identical to useEffect, but it fires synchronously after all DOM mutations. Use this to read layout from the DOM and synchronously re-render. Updates scheduled inside useLayoutEffect will be flushed synchronously, before the browser has a chance to paint.

more
less

Prefer the standard useEffect when possible to avoid blocking visual updates.

If you’re migrating code from a class component, useLayoutEffect fires in the same phase as componentDidMount and componentDidUpdate.

@version — 16.8.0

@see — ://react.dev/reference/react/useLayoutEffect

export function useLayoutEffect(effect: EffectCallback, deps?: DependencyList): void

useEffect

decl

Accepts a function that contains imperative, possibly effectful code.

more
less

@param — Imperative function that can return a cleanup function

@param — If present, effect will only activate if the values in the list change.

@version — 16.8.0

@see — ://react.dev/reference/react/useEffect

export function useEffect(effect: EffectCallback, deps?: DependencyList): void

useImperativeHandle

decl

useImperativeHandle customizes the instance value that is exposed to parent components when using ref. As always, imperative code using refs should be avoided in most cases.

more
less

useImperativeHandle should be used with React.forwardRef.

@version — 16.8.0

@see — ://react.dev/reference/react/useImperativeHandle

export function useImperativeHandle<T, R extends T>(ref: Ref<T> | undefined, init: () => R, deps?: DependencyList): void

useCallback

decl

useCallback will return a memoized version of the callback that only changes if one of the inputs has changed.

more
less

@version — 16.8.0

@see — ://react.dev/reference/react/useCallback

export function useCallback<T extends Function>(callback: T, deps: DependencyList): T

useMemo

decl

useMemo will only recompute the memoized value when one of the deps has changed.

more
less

@version — 16.8.0

@see — ://react.dev/reference/react/useMemo

export function useMemo<T>(factory: () => T, deps: DependencyList | undefined): T

useDebugValue

decl

useDebugValue can be used to display a label for custom hooks in React DevTools.

more
less

NOTE: We don’t recommend adding debug values to every custom hook. It’s most valuable for custom hooks that are part of shared libraries.

@version — 16.8.0

@see — ://react.dev/reference/react/useDebugValue

export function useDebugValue<T>(value: T, format?: (value: T) => any): void

useDeferredValue

decl

Returns a deferred version of the value that may “lag behind” it.

more
less

This is commonly used to keep the interface responsive when you have something that renders immediately based on user input and something that needs to wait for a data fetch.

A good example of this is a text input.

@param — The value that is going to be deferred

@see — ://react.dev/reference/react/useDeferredValue

export function useDeferredValue<T>(value: T): T

useTransition

decl

Allows components to avoid undesirable loading states by waiting for content to load before transitioning to the next screen. It also allows components to defer slower, data fetching updates until subsequent renders so that more crucial updates can be rendered immediately.

more
less

The useTransition hook returns two values in an array.

The first is a boolean, React’s way of informing us whether we’re waiting for the transition to finish. The second is a function that takes a callback. We can use it to tell React which state we want to defer.

If some state update causes a component to suspend, that state update should be wrapped in a transition.

@see — ://react.dev/reference/react/useTransition

export function useTransition(): [boolean, TransitionStartFunction]

startTransition

decl

Similar to useTransition but allows uses where hooks are not available.

more
less

@param — A synchronous function which causes state updates that can be deferred.

export function startTransition(scope: TransitionFunction): void

useId

decl
export function useId(): string

useInsertionEffect

decl

@param — Imperative function that can return a cleanup function

more
less

@param — If present, effect will only activate if the values in the list change.

@see — ://github.com/facebook/react/pull/21913

export function useInsertionEffect(effect: EffectCallback, deps?: DependencyList): void

useSyncExternalStore

decl

@param —

more
less

@param —

@see — ://github.com/reactwg/react-18/discussions/86

export function useSyncExternalStore<Snapshot>(subscribe: (onStoreChange: () => void) => () => void, getSnapshot: () => Snapshot, getServerSnapshot?: () => Snapshot): Snapshot

ElementType

decl
export type ElementType<P = any> = {
[K in keyof IntrinsicElements]: P extends IntrinsicElements[K] ? K : never;
}[keyof IntrinsicElements] | ComponentType<P>
Referenced by

JSXElementConstructor

decl
export type JSXElementConstructor<P> = ((props: P, deprecatedLegacyContext?: any) => ReactNode) | (new (props: P, deprecatedLegacyContext?: any) => Component<any, any>)
Referenced by

RefObject

decl
export interface RefObject<T> {
readonly current: T | null;
}
Referenced by

RefCallback

decl
export type RefCallback<T> = {
bivarianceHack(instance: T | null): void;
}["bivarianceHack"]
Referenced by

LegacyRef

decl
export type LegacyRef<T> = string | Ref<T>
Referenced by

ElementRef

decl

Gets the instance type for a React element. The instance will be different for various component types:

more
less
  • React class components will be the class instance. So if you had class Foo extends React.Component<{}> {} and used React.ElementRef<typeof Foo> then the type would be the instance of Foo.
  • React stateless functional components do not have a backing instance and so React.ElementRef<typeof Bar> (when Bar is function Bar() {}) will give you the undefined type.
  • JSX intrinsics like div will give you their DOM instance. For React.ElementRef<'div'> that would be HTMLDivElement. For React.ElementRef<'input'> that would be HTMLInputElement.
  • React stateless functional components that forward a ref will give you the ElementRef of the forwarded to component.

C must be the type of a React component so you need to use typeof as in React.ElementRef<typeof MyComponent>.

@todo — In Flow, this works a little different with forwarded refs and the AbstractComponent that React.forwardRef() returns.

export type ElementRef<C extends ForwardRefExoticComponent<any> | {
new (props: any): Component<any>;
} | ((props: any, context?: any) => ReactNode) | keyof IntrinsicElements> = "ref" extends keyof ComponentPropsWithRef<C> ? NonNullable<ComponentPropsWithRef<C>["ref"]> extends Ref<infer Instance> ? Instance : never : never

Key

decl
export type Key = string | number | bigint
Referenced by

Attributes

decl

@internal — You shouldn't need to use this type since you never see these attributes inside your component or have to validate them.

export interface Attributes {
key?: Key | null | undefined;
}
Referenced by

RefAttributes

decl
export interface RefAttributes<T> extends Attributes {

Allows getting a ref to the component instance. Once the component unmounts, React will set ref.current to null (or call the ref with null if you passed a callback ref).

more
less

@see — ://react.dev/learn/referencing-values-with-refs#refs-and-the-dom

ref?: Ref<T> | undefined;
}
Referenced by

ClassAttributes

decl
export interface ClassAttributes<T> extends Attributes {

Allows getting a ref to the component instance. Once the component unmounts, React will set ref.current to null (or call the ref with null if you passed a callback ref).

more
less

@see — ://react.dev/learn/referencing-values-with-refs#refs-and-the-dom

ref?: LegacyRef<T> | undefined;
}
Referenced by

ReactComponentElement

decl
export interface ReactComponentElement<T extends keyof IntrinsicElements | JSXElementConstructor<any>, P = Pick<ComponentProps<T>, Exclude<keyof ComponentProps<T>, "key" | "ref">>> extends ReactElement<P, Exclude<T, number>> {}

FunctionComponentElement

decl
export interface FunctionComponentElement<P> extends ReactElement<P, FunctionComponent<P>> {
ref?: ("ref" extends keyof P ? P extends {
ref?: infer R | undefined;
} ? R : never : never) | undefined;
}
Referenced by

ComponentElement

decl
export interface ComponentElement<P, T extends Component<P, ComponentState>> extends ReactElement<P, ComponentClass<P>> {
ref?: LegacyRef<T> | undefined;
}
Referenced by

ClassicElement

decl
export type ClassicElement<P> = CElement<P, ClassicComponent<P, ComponentState>>

DOMElement

decl
export interface DOMElement<P extends HTMLAttributes<T> | SVGAttributes<T>, T extends Element> extends ReactElement<P, string> {
ref: LegacyRef<T>;
}
Referenced by

ReactHTMLElement

decl
export interface ReactHTMLElement<T extends HTMLElement> extends DetailedReactHTMLElement<AllHTMLAttributes<T>, T> {}
Referenced by

DetailedReactHTMLElement

decl
export interface DetailedReactHTMLElement<P extends HTMLAttributes<T>, T extends HTMLElement> extends DOMElement<P, T> {
type: keyof ReactHTML;
}
Referenced by

ReactSVGElement

decl
export interface ReactSVGElement extends DOMElement<SVGAttributes<SVGElement>, SVGElement> {
type: keyof ReactSVG;
}
Referenced by

ReactPortal

decl
export interface ReactPortal extends ReactElement {
children: ReactNode;
}
Referenced by

Factory

decl
export type Factory<P> = (props?: Attributes & P, ...children: ReactNode[]) => ReactElement<P>
Referenced by

SFCFactory

decl

@deprecated — Please use FunctionComponentFactory

export type SFCFactory<P> = FunctionComponentFactory<P>

FunctionComponentFactory

decl
export type FunctionComponentFactory<P> = (props?: Attributes & P, ...children: ReactNode[]) => FunctionComponentElement<P>
Referenced by

ComponentFactory

decl
export type ComponentFactory<P, T extends Component<P, ComponentState>> = (props?: ClassAttributes<T> & P, ...children: ReactNode[]) => CElement<P, T>
Referenced by

CFactory

decl
export type CFactory<P, T extends Component<P, ComponentState>> = ComponentFactory<P, T>
Referenced by

ClassicFactory

decl
export type ClassicFactory<P> = CFactory<P, ClassicComponent<P, ComponentState>>

DOMFactory

decl
export type DOMFactory<P extends DOMAttributes<T>, T extends Element> = (props?: ClassAttributes<T> & P | null, ...children: ReactNode[]) => DOMElement<P, T>
Referenced by

HTMLFactory

decl
export interface HTMLFactory<T extends HTMLElement> extends DetailedHTMLFactory<AllHTMLAttributes<T>, T> {}
Referenced by

DetailedHTMLFactory

decl
export interface DetailedHTMLFactory<P extends HTMLAttributes<T>, T extends HTMLElement> extends DOMFactory<P, T> {
(props?: ClassAttributes<T> & P | null, ...children: ReactNode[]): DetailedReactHTMLElement<P, T>;
}
Referenced by

SVGFactory

decl
export interface SVGFactory extends DOMFactory<SVGAttributes<SVGElement>, SVGElement> {
(props?: ClassAttributes<SVGElement> & SVGAttributes<SVGElement> | null, ...children: ReactNode[]): ReactSVGElement;
}
Referenced by

ReactText

decl

@deprecated — - This type is not relevant when using React. Inline the type instead to make the intent clear.

export type ReactText = string | number

ReactChild

decl

@deprecated — - This type is not relevant when using React. Inline the type instead to make the intent clear.

export type ReactChild = ReactElement | string | number

ReactNodeArray

decl

@deprecated — Use either ReactNode[] if you need an array or Iterable<ReactNode> if its passed to a host component.

export interface ReactNodeArray extends readonly ReactNode[] {}

ReactFragment

decl

@deprecated — - This type is not relevant when using React. Inline the type instead to make the intent clear.

export type ReactFragment = Iterable<ReactNode>

DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_REACT_NODES

decl

For internal usage only. Different release channels declare additional types of ReactNode this particular release channel accepts. App or library types should never augment this interface.

export interface DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_REACT_NODES {}
Referenced by

ProviderProps

decl
export interface ProviderProps<T> {
value: T;
children?: ReactNode | undefined;
}
Referenced by

ConsumerProps

decl
export interface ConsumerProps<T> {
children: (value: T) => ReactNode;
}
Referenced by

ExoticComponent

decl
export interface ExoticComponent<P = {}> {

NOTE: Exotic components are not callable.

(props: P): ReactNode;
readonly $$typeof: symbol;
}
Referenced by

NamedExoticComponent

decl
export interface NamedExoticComponent<P = {}> extends ExoticComponent<P> {
displayName?: string | undefined;
}
Referenced by

ProviderExoticComponent

decl
export interface ProviderExoticComponent<P> extends ExoticComponent<P> {
propTypes?: WeakValidationMap<P> | undefined;
}
Referenced by

ContextType

decl
export type ContextType<C extends Context<any>> = C extends Context<infer T> ? T : never

Provider

decl
export type Provider<T> = ProviderExoticComponent<ProviderProps<T>>
Referenced by

Consumer

decl
export type Consumer<T> = ExoticComponent<ConsumerProps<T>>
Referenced by

Context

decl
export interface Context<T> {
Provider: Provider<T>;
Consumer: Consumer<T>;
displayName?: string | undefined;
}
Referenced by

Children

decl
export const Children: {
map<T, C>(children: C | readonly C[], fn: (child: C, index: number) => T): C extends null | undefined ? C : Exclude<T, boolean | null | undefined>[];
forEach<C>(children: C | readonly C[], fn: (child: C, index: number) => void): void;
count(children: any): number;
only<C>(children: C): C extends any[] ? never : C;
toArray(children: ReactNode | ReactNode[]): Exclude<ReactNode, boolean | null | undefined>[];
} = ...

Fragment

decl
export const Fragment: ExoticComponent<{
children?: ReactNode | undefined;
}> = ...

StrictMode

decl
export const StrictMode: ExoticComponent<{
children?: ReactNode | undefined;
}> = ...

SuspenseProps

decl
export interface SuspenseProps {
children?: ReactNode | undefined;

A fallback react tree to show when a Suspense child (like React.lazy) suspends

fallback?: ReactNode;
}
Referenced by

Suspense

decl
export const Suspense: ExoticComponent<SuspenseProps> = ...

version

decl
export const version: string = ...

ProfilerOnRenderCallback

decl

://react.dev/reference/react/Profiler#onrender-callback Profiler API

export type ProfilerOnRenderCallback = (id: string, phase: "mount" | "update" | "nested-update", actualDuration: number, baseDuration: number, startTime: number, commitTime: number, interactions: Set<SchedulerInteraction>) => void
Referenced by

ProfilerProps

decl
export interface ProfilerProps {
children?: ReactNode | undefined;
id: string;
onRender: ProfilerOnRenderCallback;
}
Referenced by

Profiler

decl
export const Profiler: ExoticComponent<ProfilerProps> = ...

ReactInstance

decl
export type ReactInstance = Component<any> | Element
Referenced by

Component

decldecl
export interface Component<P = {}, S = {}, SS = any> extends ComponentLifecycle<P, S, SS> {}
export class Component<P, S> {
constructor(props: Readonly<P> | P)

@deprecated —

more
less

@see — ://legacy.reactjs.org/docs/legacy-context.html

constructor(props: P, context: any)

If set, this.context will be set at runtime to the current value of the given Context.

more
less

Usage:

type MyContext = number
const Ctx = React.createContext<MyContext>(0)
class Foo extends React.Component {
  static contextType = Ctx
  context!: React.ContextType<typeof Ctx>
  render () {
    return <>My context's value: {this.context}</>;
  }
}

@see — ://react.dev/reference/react/Component#static-contexttype

static contextType?: Context<any> | undefined;

If using the new style context, re-declare this in your class to be the React.ContextType of your static contextType. Should be used with type annotation or static contextType.

more
less
 
static contextType = MyContext
// For TS pre-3.7:
context!: React.ContextType<typeof MyContext>
// For TS 3.7 and above:
declare context: React.ContextType<typeof MyContext>

@see — ://react.dev/reference/react/Component#context

context: unknown;
setState<K extends keyof S>(state: ((prevState: Readonly<S>, props: Readonly<P>) => Pick<S, K> | S | null) | (Pick<S, K> | S | null), callback?: () => void): void;
forceUpdate(callback?: () => void): void;
render(): ReactNode;
readonly props: Readonly<P>;
state: Readonly<S>;

@deprecated — https://legacy.reactjs.org/docs/refs-and-the-dom.html#legacy-api-string-refs

refs: {
[key: string]: ReactInstance;
};
}
Referenced by

PureComponent

decl
export class PureComponent<P = {}, S = {}, SS = any> extends Component<P, S, SS> {}

ClassicComponent

decl
export interface ClassicComponent<P = {}, S = {}> extends Component<P, S> {
replaceState(nextState: S, callback?: () => void): void;
isMounted(): boolean;
getInitialState(): S;
}
Referenced by

ChildContextProvider

decl
export interface ChildContextProvider<CC> {
getChildContext(): CC;
}

FC

decl
export type FC<P = {}> = FunctionComponent<P>

FunctionComponent

decl
export interface FunctionComponent<P = {}> {
(props: P, context?: any): ReactNode;
propTypes?: WeakValidationMap<P> | undefined;
contextTypes?: ValidationMap<any> | undefined;
defaultProps?: Partial<P> | undefined;
displayName?: string | undefined;
}
Referenced by

VFC

decl

@deprecated — - Equivalent with React.FC.

export type VFC<P = {}> = VoidFunctionComponent<P>

VoidFunctionComponent

decl

@deprecated — - Equivalent with React.FunctionComponent.

export interface VoidFunctionComponent<P = {}> {
(props: P, context?: any): ReactNode;
propTypes?: WeakValidationMap<P> | undefined;
contextTypes?: ValidationMap<any> | undefined;
defaultProps?: Partial<P> | undefined;
displayName?: string | undefined;
}
Referenced by

ForwardedRef

decl
export type ForwardedRef<T> = ((instance: T | null) => void) | MutableRefObject<T | null> | null
Referenced by

ForwardRefRenderFunction

decl
export interface ForwardRefRenderFunction<T, P = {}> {
(props: P, ref: ForwardedRef<T>): ReactNode;
displayName?: string | undefined;

defaultProps are not supported on render functions

defaultProps?: never | undefined;

propTypes are not supported on render functions

propTypes?: never | undefined;
}
Referenced by

ComponentClass

decl
export interface ComponentClass<P = {}, S = ComponentState> extends StaticLifecycle<P, S> {
new (props: P, context?: any): Component<P, S>;
propTypes?: WeakValidationMap<P> | undefined;
contextType?: Context<any> | undefined;
contextTypes?: ValidationMap<any> | undefined;
childContextTypes?: ValidationMap<any> | undefined;
defaultProps?: Partial<P> | undefined;
displayName?: string | undefined;
}
Referenced by

ClassicComponentClass

decl
export interface ClassicComponentClass<P = {}> extends ComponentClass<P> {
new (props: P, context?: any): ClassicComponent<P, ComponentState>;
getDefaultProps(): P;
}
Referenced by

ClassType

decl

We use an intersection type to infer multiple type parameters from a single argument, which is useful for many top-level API defs. See https://github.com/Microsoft/TypeScript/issues/7234 for more info.

export type ClassType<P, T extends Component<P, ComponentState>, C extends ComponentClass<P>> = C & (new (props: P, context?: any) => T)
Referenced by

ComponentLifecycle

decl
export interface ComponentLifecycle<P, S, SS = any> extends NewLifecycle<P, S, SS>, DeprecatedLifecycle<P, S> {

Called immediately after a component is mounted. Setting state here will trigger re-rendering.

componentDidMount(): void;

Called to determine whether the change in props and state should trigger a re-render.

more
less

Component always returns true. PureComponent implements a shallow comparison on props and state and returns true if any props or states have changed.

If false is returned, Component#render, componentWillUpdate and componentDidUpdate will not be called.

shouldComponentUpdate(nextProps: Readonly<P>, nextState: Readonly<S>, nextContext: any): boolean;

Called immediately before a component is destroyed. Perform any necessary cleanup in this method, such as cancelled network requests, or cleaning up any DOM elements created in componentDidMount.

componentWillUnmount(): void;

Catches exceptions generated in descendant components. Unhandled exceptions will cause the entire component tree to unmount.

componentDidCatch(error: Error, errorInfo: ErrorInfo): void;
}
Referenced by

StaticLifecycle

decl
export interface StaticLifecycle<P, S> {
getDerivedStateFromProps?: GetDerivedStateFromProps<P, S> | undefined;
getDerivedStateFromError?: GetDerivedStateFromError<P, S> | undefined;
}
Referenced by

GetDerivedStateFromProps

decl
export type GetDerivedStateFromProps<P, S> = (nextProps: Readonly<P>, prevState: S) => Partial<S> | null
Referenced by

GetDerivedStateFromError

decl
export type GetDerivedStateFromError<P, S> = (error: any) => Partial<S> | null
Referenced by

NewLifecycle

decl
export interface NewLifecycle<P, S, SS> {

Runs before React applies the result of render to the document, and returns an object to be given to componentDidUpdate. Useful for saving things such as scroll position before render causes changes to it.

more
less

Note: the presence of getSnapshotBeforeUpdate prevents any of the deprecated lifecycle events from running.

getSnapshotBeforeUpdate(prevProps: Readonly<P>, prevState: Readonly<S>): SS | null;

Called immediately after updating occurs. Not called for the initial render.

more
less

The snapshot is only present if getSnapshotBeforeUpdate is present and returns non-null.

componentDidUpdate(prevProps: Readonly<P>, prevState: Readonly<S>, snapshot?: SS): void;
}
Referenced by

DeprecatedLifecycle

decl
export interface DeprecatedLifecycle<P, S> {

Called immediately before mounting occurs, and before Component#render. Avoid introducing any side-effects or subscriptions in this method.

more
less

Note: the presence of getSnapshotBeforeUpdate or getDerivedStateFromProps prevents this from being invoked.

@deprecated — 16.3, use componentDidMount or the constructor instead; will stop working in React 17

@see — ://legacy.reactjs.org/blog/2018/03/27/update-on-async-rendering.html#initializing-state

@see — ://legacy.reactjs.org/blog/2018/03/27/update-on-async-rendering.html#gradual-migration-path

componentWillMount(): void;

Called immediately before mounting occurs, and before Component#render. Avoid introducing any side-effects or subscriptions in this method.

more
less

This method will not stop working in React 17.

Note: the presence of getSnapshotBeforeUpdate or getDerivedStateFromProps prevents this from being invoked.

@deprecated — 16.3, use componentDidMount or the constructor instead

@see — ://legacy.reactjs.org/blog/2018/03/27/update-on-async-rendering.html#initializing-state

@see — ://legacy.reactjs.org/blog/2018/03/27/update-on-async-rendering.html#gradual-migration-path

UNSAFE_componentWillMount(): void;

Called when the component may be receiving new props. React may call this even if props have not changed, so be sure to compare new and existing props if you only want to handle changes.

more
less

Calling Component#setState generally does not trigger this method.

Note: the presence of getSnapshotBeforeUpdate or getDerivedStateFromProps prevents this from being invoked.

@deprecated — 16.3, use static getDerivedStateFromProps instead; will stop working in React 17

@see — ://legacy.reactjs.org/blog/2018/03/27/update-on-async-rendering.html#updating-state-based-on-props

@see — ://legacy.reactjs.org/blog/2018/03/27/update-on-async-rendering.html#gradual-migration-path

componentWillReceiveProps(nextProps: Readonly<P>, nextContext: any): void;

Called when the component may be receiving new props. React may call this even if props have not changed, so be sure to compare new and existing props if you only want to handle changes.

more
less

Calling Component#setState generally does not trigger this method.

This method will not stop working in React 17.

Note: the presence of getSnapshotBeforeUpdate or getDerivedStateFromProps prevents this from being invoked.

@deprecated — 16.3, use static getDerivedStateFromProps instead

@see — ://legacy.reactjs.org/blog/2018/03/27/update-on-async-rendering.html#updating-state-based-on-props

@see — ://legacy.reactjs.org/blog/2018/03/27/update-on-async-rendering.html#gradual-migration-path

UNSAFE_componentWillReceiveProps(nextProps: Readonly<P>, nextContext: any): void;

Called immediately before rendering when new props or state is received. Not called for the initial render.

more
less

Note: You cannot call Component#setState here.

Note: the presence of getSnapshotBeforeUpdate or getDerivedStateFromProps prevents this from being invoked.

@deprecated — 16.3, use getSnapshotBeforeUpdate instead; will stop working in React 17

@see — ://legacy.reactjs.org/blog/2018/03/27/update-on-async-rendering.html#reading-dom-properties-before-an-update

@see — ://legacy.reactjs.org/blog/2018/03/27/update-on-async-rendering.html#gradual-migration-path

componentWillUpdate(nextProps: Readonly<P>, nextState: Readonly<S>, nextContext: any): void;

Called immediately before rendering when new props or state is received. Not called for the initial render.

more
less

Note: You cannot call Component#setState here.

This method will not stop working in React 17.

Note: the presence of getSnapshotBeforeUpdate or getDerivedStateFromProps prevents this from being invoked.

@deprecated — 16.3, use getSnapshotBeforeUpdate instead

@see — ://legacy.reactjs.org/blog/2018/03/27/update-on-async-rendering.html#reading-dom-properties-before-an-update

@see — ://legacy.reactjs.org/blog/2018/03/27/update-on-async-rendering.html#gradual-migration-path

UNSAFE_componentWillUpdate(nextProps: Readonly<P>, nextState: Readonly<S>, nextContext: any): void;
}
Referenced by

Mixin

decl
export interface Mixin<P, S> extends ComponentLifecycle<P, S> {
mixins?: Mixin<P, S>[] | undefined;
statics?: {
[key: string]: any;
} | undefined;
displayName?: string | undefined;
propTypes?: ValidationMap<any> | undefined;
contextTypes?: ValidationMap<any> | undefined;
childContextTypes?: ValidationMap<any> | undefined;
getDefaultProps(): P;
getInitialState(): S;
}
Referenced by

ComponentSpec

decl
export interface ComponentSpec<P, S> extends Mixin<P, S> {
render(): ReactNode;
[key: string]: any;
}

ForwardRefExoticComponent

decl
export interface ForwardRefExoticComponent<P> extends NamedExoticComponent<P> {
defaultProps?: Partial<P> | undefined;
propTypes?: WeakValidationMap<P> | undefined;
}
Referenced by

PropsWithoutRef

decl

Ensures that the props do not include ref at all

export type PropsWithoutRef<P> = P extends any ? ("ref" extends keyof P ? Omit<P, "ref"> : P) : P
Referenced by

PropsWithRef

decl

Ensures that the props do not include string ref, which cannot be forwarded

export type PropsWithRef<P> = "ref" extends keyof P ? P extends {
ref?: infer R | undefined;
} ? string extends R ? PropsWithoutRef<P> & {
ref?: Exclude<R, string> | undefined;
} : P : P : P
Referenced by

PropsWithChildren

decl
export type PropsWithChildren<P = unknown> = P & {
children?: ReactNode | undefined;
}

ComponentProps

decl

NOTE: prefer ComponentPropsWithRef, if the ref is forwarded, or ComponentPropsWithoutRef when refs are not supported.

export type ComponentProps<T extends keyof IntrinsicElements | JSXElementConstructor<any>> = T extends JSXElementConstructor<infer P> ? P : T extends keyof IntrinsicElements ? IntrinsicElements[T] : {}
Referenced by

ComponentPropsWithRef

decl
export type ComponentPropsWithRef<T extends ElementType> = T extends (new (props: infer P) => Component<any, any>) ? PropsWithoutRef<P> & RefAttributes<InstanceType<T>> : PropsWithRef<ComponentProps<T>>
Referenced by

ComponentPropsWithoutRef

decl
export type ComponentPropsWithoutRef<T extends ElementType> = PropsWithoutRef<ComponentProps<T>>
Referenced by

ComponentRef

decl
export type ComponentRef<T extends ElementType> = T extends NamedExoticComponent<ComponentPropsWithoutRef<T> & RefAttributes<infer Method>> ? Method : ComponentPropsWithRef<T> extends RefAttributes<infer Method> ? Method : never

MemoExoticComponent

decl
export type MemoExoticComponent<T extends ComponentType<any>> = NamedExoticComponent<ComponentPropsWithRef<T>> & {
readonly type: T;
}
Referenced by

LazyExoticComponent

decl
export type LazyExoticComponent<T extends ComponentType<any>> = ExoticComponent<ComponentPropsWithRef<T>> & {
readonly _result: T;
}
Referenced by

SetStateAction

decl
export type SetStateAction<S> = S | ((prevState: S) => S)
Referenced by

Dispatch

decl
export type Dispatch<A> = (value: A) => void
Referenced by

DispatchWithoutAction

decl
export type DispatchWithoutAction = () => void
Referenced by

Reducer

decl
export type Reducer<S, A> = (prevState: S, action: A) => S
Referenced by

ReducerWithoutAction

decl
export type ReducerWithoutAction<S> = (prevState: S) => S
Referenced by

ReducerState

decl
export type ReducerState<R extends Reducer<any, any>> = R extends Reducer<infer S, any> ? S : never
Referenced by

ReducerAction

decl
export type ReducerAction<R extends Reducer<any, any>> = R extends Reducer<any, infer A> ? A : never
Referenced by

ReducerStateWithoutAction

decl
export type ReducerStateWithoutAction<R extends ReducerWithoutAction<any>> = R extends ReducerWithoutAction<infer S> ? S : never
Referenced by

EffectCallback

decl
export type EffectCallback = () => void | Destructor
Referenced by
Unexported symbols referenced here

Destructor

decl
type Destructor = () => void | {
[UNDEFINED_VOID_ONLY]: never;
}
Referenced by

MutableRefObject

decl
export interface MutableRefObject<T> {
current: T;
}
Referenced by

TransitionFunction

decl
export type TransitionFunction = () => VoidOrUndefinedOnly
Referenced by
Unexported symbols referenced here

VoidOrUndefinedOnly

decl
type VoidOrUndefinedOnly = void | {
[UNDEFINED_VOID_ONLY]: never;
}
Referenced by

TransitionStartFunction

decl
export interface TransitionStartFunction {

State updates caused inside the callback are allowed to be deferred.

more
less

If some state update causes a component to suspend, that state update should be wrapped in a transition.

@param — A synchronous function which causes state updates that can be deferred.

(callback: TransitionFunction): void;
}
Referenced by

BaseSyntheticEvent

decl
export interface BaseSyntheticEvent<E = object, C = any, T = any> {
nativeEvent: E;
currentTarget: C;
target: T;
bubbles: boolean;
cancelable: boolean;
defaultPrevented: boolean;
eventPhase: number;
isTrusted: boolean;
preventDefault(): void;
isDefaultPrevented(): boolean;
stopPropagation(): void;
isPropagationStopped(): boolean;
persist(): void;
timeStamp: number;
type: string;
}
Referenced by

SyntheticEvent

decl

currentTarget - a reference to the element on which the event listener is registered.

more
less

target - a reference to the element from which the event was originally dispatched. This might be a child element to the element on which the event listener is registered. If you thought this should be EventTarget & T, see https://github.com/DefinitelyTyped/DefinitelyTyped/issues/11508#issuecomment-256045682

export interface SyntheticEvent<T = Element, E = Event> extends BaseSyntheticEvent<E, EventTarget & T, EventTarget> {}
Referenced by

ClipboardEvent

decl
export interface ClipboardEvent<T = Element> extends SyntheticEvent<T, NativeClipboardEvent> {
clipboardData: DataTransfer;
}
Referenced by
Unexported symbols referenced here

NativeClipboardEvent

decl
type NativeClipboardEvent = ClipboardEvent
Referenced by

CompositionEvent

decl
export interface CompositionEvent<T = Element> extends SyntheticEvent<T, NativeCompositionEvent> {
data: string;
}
Referenced by
Unexported symbols referenced here

NativeCompositionEvent

decl
type NativeCompositionEvent = CompositionEvent
Referenced by

DragEvent

decl
export interface DragEvent<T = Element> extends MouseEvent<T, NativeDragEvent> {
dataTransfer: DataTransfer;
}
Referenced by
Unexported symbols referenced here

NativeDragEvent

decl
type NativeDragEvent = DragEvent
Referenced by

PointerEvent

decl
export interface PointerEvent<T = Element> extends MouseEvent<T, NativePointerEvent> {
pointerId: number;
pressure: number;
tangentialPressure: number;
tiltX: number;
tiltY: number;
twist: number;
width: number;
height: number;
pointerType: "mouse" | "pen" | "touch";
isPrimary: boolean;
}
Referenced by
Unexported symbols referenced here

NativePointerEvent

decl
type NativePointerEvent = PointerEvent
Referenced by

FocusEvent

decl
export interface FocusEvent<Target = Element, RelatedTarget = Element> extends SyntheticEvent<Target, NativeFocusEvent> {
relatedTarget: (EventTarget & RelatedTarget) | null;
target: EventTarget & Target;
}
Referenced by
Unexported symbols referenced here

NativeFocusEvent

decl
type NativeFocusEvent = FocusEvent
Referenced by

FormEvent

decl
export interface FormEvent<T = Element> extends SyntheticEvent<T> {}
Referenced by

InvalidEvent

decl
export interface InvalidEvent<T = Element> extends SyntheticEvent<T> {
target: EventTarget & T;
}

ChangeEvent

decl
export interface ChangeEvent<T = Element> extends SyntheticEvent<T> {
target: EventTarget & T;
}
Referenced by

ModifierKey

decl
export type ModifierKey = "Alt" | "AltGraph" | "CapsLock" | "Control" | "Fn" | "FnLock" | "Hyper" | "Meta" | "NumLock" | "ScrollLock" | "Shift" | "Super" | "Symbol" | "SymbolLock"
Referenced by

KeyboardEvent

decl
export interface KeyboardEvent<T = Element> extends UIEvent<T, NativeKeyboardEvent> {
altKey: boolean;

@deprecated —

charCode: number;
ctrlKey: boolean;
code: string;

See DOM Level 3 Events spec. for a list of valid (case-sensitive) arguments to this method.

getModifierState(key: ModifierKey): boolean;

See the DOM Level 3 Events spec. for possible values

key: string;

@deprecated —

keyCode: number;
locale: string;
location: number;
metaKey: boolean;
repeat: boolean;
shiftKey: boolean;

@deprecated —

which: number;
}
Referenced by
Unexported symbols referenced here

NativeKeyboardEvent

decl
type NativeKeyboardEvent = KeyboardEvent
Referenced by

MouseEvent

decl
export interface MouseEvent<T = Element, E = NativeMouseEvent> extends UIEvent<T, E> {
altKey: boolean;
button: number;
buttons: number;
clientX: number;
clientY: number;
ctrlKey: boolean;

See DOM Level 3 Events spec. for a list of valid (case-sensitive) arguments to this method.

getModifierState(key: ModifierKey): boolean;
metaKey: boolean;
movementX: number;
movementY: number;
pageX: number;
pageY: number;
relatedTarget: EventTarget | null;
screenX: number;
screenY: number;
shiftKey: boolean;
}
Referenced by
Unexported symbols referenced here

NativeMouseEvent

decl
type NativeMouseEvent = MouseEvent
Referenced by

TouchEvent

decl
export interface TouchEvent<T = Element> extends UIEvent<T, NativeTouchEvent> {
altKey: boolean;
changedTouches: TouchList;
ctrlKey: boolean;

See DOM Level 3 Events spec. for a list of valid (case-sensitive) arguments to this method.

getModifierState(key: ModifierKey): boolean;
metaKey: boolean;
shiftKey: boolean;
targetTouches: TouchList;
touches: TouchList;
}
Referenced by
Unexported symbols referenced here

NativeTouchEvent

decl
type NativeTouchEvent = TouchEvent
Referenced by

UIEvent

decl
export interface UIEvent<T = Element, E = NativeUIEvent> extends SyntheticEvent<T, E> {
detail: number;
view: AbstractView;
}
Referenced by
Unexported symbols referenced here

NativeUIEvent

decl
type NativeUIEvent = UIEvent
Referenced by

WheelEvent

decl
export interface WheelEvent<T = Element> extends MouseEvent<T, NativeWheelEvent> {
deltaMode: number;
deltaX: number;
deltaY: number;
deltaZ: number;
}
Referenced by
Unexported symbols referenced here

NativeWheelEvent

decl
type NativeWheelEvent = WheelEvent
Referenced by

AnimationEvent

decl
export interface AnimationEvent<T = Element> extends SyntheticEvent<T, NativeAnimationEvent> {
animationName: string;
elapsedTime: number;
pseudoElement: string;
}
Referenced by
Unexported symbols referenced here

NativeAnimationEvent

decl
type NativeAnimationEvent = AnimationEvent
Referenced by

TransitionEvent

decl
export interface TransitionEvent<T = Element> extends SyntheticEvent<T, NativeTransitionEvent> {
elapsedTime: number;
propertyName: string;
pseudoElement: string;
}
Referenced by
Unexported symbols referenced here

NativeTransitionEvent

decl
type NativeTransitionEvent = TransitionEvent
Referenced by

ClipboardEventHandler

decl
export type ClipboardEventHandler<T = Element> = EventHandler<ClipboardEvent<T>>
Referenced by

CompositionEventHandler

decl
export type CompositionEventHandler<T = Element> = EventHandler<CompositionEvent<T>>
Referenced by

DragEventHandler

decl
export type DragEventHandler<T = Element> = EventHandler<DragEvent<T>>
Referenced by

FocusEventHandler

decl
export type FocusEventHandler<T = Element> = EventHandler<FocusEvent<T>>
Referenced by

FormEventHandler

decl
export type FormEventHandler<T = Element> = EventHandler<FormEvent<T>>
Referenced by

KeyboardEventHandler

decl
export type KeyboardEventHandler<T = Element> = EventHandler<KeyboardEvent<T>>
Referenced by

MouseEventHandler

decl
export type MouseEventHandler<T = Element> = EventHandler<MouseEvent<T>>
Referenced by

TouchEventHandler

decl
export type TouchEventHandler<T = Element> = EventHandler<TouchEvent<T>>
Referenced by

PointerEventHandler

decl
export type PointerEventHandler<T = Element> = EventHandler<PointerEvent<T>>
Referenced by

UIEventHandler

decl
export type UIEventHandler<T = Element> = EventHandler<UIEvent<T>>
Referenced by

WheelEventHandler

decl
export type WheelEventHandler<T = Element> = EventHandler<WheelEvent<T>>
Referenced by

AnimationEventHandler

decl
export type AnimationEventHandler<T = Element> = EventHandler<AnimationEvent<T>>
Referenced by

TransitionEventHandler

decl
export type TransitionEventHandler<T = Element> = EventHandler<TransitionEvent<T>>
Referenced by

HTMLProps

decl
export interface HTMLProps<T> extends AllHTMLAttributes<T>, ClassAttributes<T> {}

DetailedHTMLProps

decl
export type DetailedHTMLProps<E extends HTMLAttributes<T>, T> = ClassAttributes<T> & E
Referenced by

SVGLineElementAttributes

decl
export interface SVGLineElementAttributes<T> extends SVGProps<T> {}
Referenced by

SVGTextElementAttributes

decl
export interface SVGTextElementAttributes<T> extends SVGProps<T> {}
Referenced by

DOMAttributes

decl
export interface DOMAttributes<T> {
children?: ReactNode | undefined;
dangerouslySetInnerHTML?: {
__html: string | TrustedHTML;
} | undefined;
onCopy?: ClipboardEventHandler<T> | undefined;
onCopyCapture?: ClipboardEventHandler<T> | undefined;
onCut?: ClipboardEventHandler<T> | undefined;
onCutCapture?: ClipboardEventHandler<T> | undefined;
onPaste?: ClipboardEventHandler<T> | undefined;
onPasteCapture?: ClipboardEventHandler<T> | undefined;
onCompositionEnd?: CompositionEventHandler<T> | undefined;
onCompositionEndCapture?: CompositionEventHandler<T> | undefined;
onCompositionStart?: CompositionEventHandler<T> | undefined;
onCompositionStartCapture?: CompositionEventHandler<T> | undefined;
onCompositionUpdate?: CompositionEventHandler<T> | undefined;
onCompositionUpdateCapture?: CompositionEventHandler<T> | undefined;
onFocus?: FocusEventHandler<T> | undefined;
onFocusCapture?: FocusEventHandler<T> | undefined;
onBlur?: FocusEventHandler<T> | undefined;
onBlurCapture?: FocusEventHandler<T> | undefined;
onChange?: FormEventHandler<T> | undefined;
onChangeCapture?: FormEventHandler<T> | undefined;
onBeforeInput?: FormEventHandler<T> | undefined;
onBeforeInputCapture?: FormEventHandler<T> | undefined;
onInput?: FormEventHandler<T> | undefined;
onInputCapture?: FormEventHandler<T> | undefined;
onReset?: FormEventHandler<T> | undefined;
onResetCapture?: FormEventHandler<T> | undefined;
onSubmit?: FormEventHandler<T> | undefined;
onSubmitCapture?: FormEventHandler<T> | undefined;
onInvalid?: FormEventHandler<T> | undefined;
onInvalidCapture?: FormEventHandler<T> | undefined;
onLoad?: ReactEventHandler<T> | undefined;
onLoadCapture?: ReactEventHandler<T> | undefined;
onError?: ReactEventHandler<T> | undefined;
onErrorCapture?: ReactEventHandler<T> | undefined;
onKeyDown?: KeyboardEventHandler<T> | undefined;
onKeyDownCapture?: KeyboardEventHandler<T> | undefined;

@deprecated —

onKeyPress?: KeyboardEventHandler<T> | undefined;

@deprecated —

onKeyPressCapture?: KeyboardEventHandler<T> | undefined;
onKeyUp?: KeyboardEventHandler<T> | undefined;
onKeyUpCapture?: KeyboardEventHandler<T> | undefined;
onAbort?: ReactEventHandler<T> | undefined;
onAbortCapture?: ReactEventHandler<T> | undefined;
onCanPlay?: ReactEventHandler<T> | undefined;
onCanPlayCapture?: ReactEventHandler<T> | undefined;
onCanPlayThrough?: ReactEventHandler<T> | undefined;
onCanPlayThroughCapture?: ReactEventHandler<T> | undefined;
onDurationChange?: ReactEventHandler<T> | undefined;
onDurationChangeCapture?: ReactEventHandler<T> | undefined;
onEmptied?: ReactEventHandler<T> | undefined;
onEmptiedCapture?: ReactEventHandler<T> | undefined;
onEncrypted?: ReactEventHandler<T> | undefined;
onEncryptedCapture?: ReactEventHandler<T> | undefined;
onEnded?: ReactEventHandler<T> | undefined;
onEndedCapture?: ReactEventHandler<T> | undefined;
onLoadedData?: ReactEventHandler<T> | undefined;
onLoadedDataCapture?: ReactEventHandler<T> | undefined;
onLoadedMetadata?: ReactEventHandler<T> | undefined;
onLoadedMetadataCapture?: ReactEventHandler<T> | undefined;
onLoadStart?: ReactEventHandler<T> | undefined;
onLoadStartCapture?: ReactEventHandler<T> | undefined;
onPause?: ReactEventHandler<T> | undefined;
onPauseCapture?: ReactEventHandler<T> | undefined;
onPlay?: ReactEventHandler<T> | undefined;
onPlayCapture?: ReactEventHandler<T> | undefined;
onPlaying?: ReactEventHandler<T> | undefined;
onPlayingCapture?: ReactEventHandler<T> | undefined;
onProgress?: ReactEventHandler<T> | undefined;
onProgressCapture?: ReactEventHandler<T> | undefined;
onRateChange?: ReactEventHandler<T> | undefined;
onRateChangeCapture?: ReactEventHandler<T> | undefined;
onResize?: ReactEventHandler<T> | undefined;
onResizeCapture?: ReactEventHandler<T> | undefined;
onSeeked?: ReactEventHandler<T> | undefined;
onSeekedCapture?: ReactEventHandler<T> | undefined;
onSeeking?: ReactEventHandler<T> | undefined;
onSeekingCapture?: ReactEventHandler<T> | undefined;
onStalled?: ReactEventHandler<T> | undefined;
onStalledCapture?: ReactEventHandler<T> | undefined;
onSuspend?: ReactEventHandler<T> | undefined;
onSuspendCapture?: ReactEventHandler<T> | undefined;
onTimeUpdate?: ReactEventHandler<T> | undefined;
onTimeUpdateCapture?: ReactEventHandler<T> | undefined;
onVolumeChange?: ReactEventHandler<T> | undefined;
onVolumeChangeCapture?: ReactEventHandler<T> | undefined;
onWaiting?: ReactEventHandler<T> | undefined;
onWaitingCapture?: ReactEventHandler<T> | undefined;
onAuxClick?: MouseEventHandler<T> | undefined;
onAuxClickCapture?: MouseEventHandler<T> | undefined;
onClick?: MouseEventHandler<T> | undefined;
onClickCapture?: MouseEventHandler<T> | undefined;
onContextMenu?: MouseEventHandler<T> | undefined;
onContextMenuCapture?: MouseEventHandler<T> | undefined;
onDoubleClick?: MouseEventHandler<T> | undefined;
onDoubleClickCapture?: MouseEventHandler<T> | undefined;
onDrag?: DragEventHandler<T> | undefined;
onDragCapture?: DragEventHandler<T> | undefined;
onDragEnd?: DragEventHandler<T> | undefined;
onDragEndCapture?: DragEventHandler<T> | undefined;
onDragEnter?: DragEventHandler<T> | undefined;
onDragEnterCapture?: DragEventHandler<T> | undefined;
onDragExit?: DragEventHandler<T> | undefined;
onDragExitCapture?: DragEventHandler<T> | undefined;
onDragLeave?: DragEventHandler<T> | undefined;
onDragLeaveCapture?: DragEventHandler<T> | undefined;
onDragOver?: DragEventHandler<T> | undefined;
onDragOverCapture?: DragEventHandler<T> | undefined;
onDragStart?: DragEventHandler<T> | undefined;
onDragStartCapture?: DragEventHandler<T> | undefined;
onDrop?: DragEventHandler<T> | undefined;
onDropCapture?: DragEventHandler<T> | undefined;
onMouseDown?: MouseEventHandler<T> | undefined;
onMouseDownCapture?: MouseEventHandler<T> | undefined;
onMouseEnter?: MouseEventHandler<T> | undefined;
onMouseLeave?: MouseEventHandler<T> | undefined;
onMouseMove?: MouseEventHandler<T> | undefined;
onMouseMoveCapture?: MouseEventHandler<T> | undefined;
onMouseOut?: MouseEventHandler<T> | undefined;
onMouseOutCapture?: MouseEventHandler<T> | undefined;
onMouseOver?: MouseEventHandler<T> | undefined;
onMouseOverCapture?: MouseEventHandler<T> | undefined;
onMouseUp?: MouseEventHandler<T> | undefined;
onMouseUpCapture?: MouseEventHandler<T> | undefined;
onSelect?: ReactEventHandler<T> | undefined;
onSelectCapture?: ReactEventHandler<T> | undefined;
onTouchCancel?: TouchEventHandler<T> | undefined;
onTouchCancelCapture?: TouchEventHandler<T> | undefined;
onTouchEnd?: TouchEventHandler<T> | undefined;
onTouchEndCapture?: TouchEventHandler<T> | undefined;
onTouchMove?: TouchEventHandler<T> | undefined;
onTouchMoveCapture?: TouchEventHandler<T> | undefined;
onTouchStart?: TouchEventHandler<T> | undefined;
onTouchStartCapture?: TouchEventHandler<T> | undefined;
onPointerDown?: PointerEventHandler<T> | undefined;
onPointerDownCapture?: PointerEventHandler<T> | undefined;
onPointerMove?: PointerEventHandler<T> | undefined;
onPointerMoveCapture?: PointerEventHandler<T> | undefined;
onPointerUp?: PointerEventHandler<T> | undefined;
onPointerUpCapture?: PointerEventHandler<T> | undefined;
onPointerCancel?: PointerEventHandler<T> | undefined;
onPointerCancelCapture?: PointerEventHandler<T> | undefined;
onPointerEnter?: PointerEventHandler<T> | undefined;
onPointerEnterCapture?: PointerEventHandler<T> | undefined;
onPointerLeave?: PointerEventHandler<T> | undefined;
onPointerLeaveCapture?: PointerEventHandler<T> | undefined;
onPointerOver?: PointerEventHandler<T> | undefined;
onPointerOverCapture?: PointerEventHandler<T> | undefined;
onPointerOut?: PointerEventHandler<T> | undefined;
onPointerOutCapture?: PointerEventHandler<T> | undefined;
onGotPointerCapture?: PointerEventHandler<T> | undefined;
onGotPointerCaptureCapture?: PointerEventHandler<T> | undefined;
onLostPointerCapture?: PointerEventHandler<T> | undefined;
onLostPointerCaptureCapture?: PointerEventHandler<T> | undefined;
onScroll?: UIEventHandler<T> | undefined;
onScrollCapture?: UIEventHandler<T> | undefined;
onWheel?: WheelEventHandler<T> | undefined;
onWheelCapture?: WheelEventHandler<T> | undefined;
onAnimationStart?: AnimationEventHandler<T> | undefined;
onAnimationStartCapture?: AnimationEventHandler<T> | undefined;
onAnimationEnd?: AnimationEventHandler<T> | undefined;
onAnimationEndCapture?: AnimationEventHandler<T> | undefined;
onAnimationIteration?: AnimationEventHandler<T> | undefined;
onAnimationIterationCapture?: AnimationEventHandler<T> | undefined;
onTransitionEnd?: TransitionEventHandler<T> | undefined;
onTransitionEndCapture?: TransitionEventHandler<T> | undefined;
}
Referenced by
Unexported symbols referenced here

TrustedHTML

decl
interface TrustedHTML {}
Referenced by

CSSProperties

decl
export interface CSSProperties extends import("csstype").Properties<string | number> {}
Referenced by

AriaAttributes

decl
export interface AriaAttributes {

Identifies the currently active element when DOM focus is on a composite widget, textbox, group, or application.

"aria-activedescendant"?: string | undefined;

Indicates whether assistive technologies will present all, or only parts of, the changed region based on the change notifications defined by the aria-relevant attribute.

"aria-atomic"?: Booleanish | undefined;

Indicates whether inputting text could trigger display of one or more predictions of the user's intended value for an input and specifies how predictions would be presented if they are made.

"aria-autocomplete"?: "none" | "inline" | "list" | "both" | undefined;

Indicates an element is being modified and that assistive technologies MAY want to wait until the modifications are complete before exposing them to the user.

more
less

Defines a string value that labels the current element, which is intended to be converted into Braille.

@see —

"aria-braillelabel"?: string | undefined;

Defines a human-readable, author-localized abbreviated description for the role of an element, which is intended to be converted into Braille.

more
less

@see —

"aria-brailleroledescription"?: string | undefined;
"aria-busy"?: Booleanish | undefined;

Indicates the current "checked" state of checkboxes, radio buttons, and other widgets.

more
less

@see —

@see —

"aria-checked"?: boolean | "false" | "mixed" | "true" | undefined;

Defines the total number of columns in a table, grid, or treegrid.

more
less

@see —

"aria-colcount"?: number | undefined;

Defines an element's column index or position with respect to the total number of columns within a table, grid, or treegrid.

more
less

@see —

@see —

"aria-colindex"?: number | undefined;

Defines a human readable text alternative of aria-colindex.

more
less

@see —

"aria-colindextext"?: string | undefined;

Defines the number of columns spanned by a cell or gridcell within a table, grid, or treegrid.

more
less

@see —

@see —

"aria-colspan"?: number | undefined;

Identifies the element (or elements) whose contents or presence are controlled by the current element.

more
less

@see —

"aria-controls"?: string | undefined;

Indicates the element that represents the current item within a container or set of related elements.

"aria-current"?: boolean | "false" | "true" | "page" | "step" | "location" | "date" | "time" | undefined;

Identifies the element (or elements) that describes the object.

more
less

@see —

"aria-describedby"?: string | undefined;

Defines a string value that describes or annotates the current element.

more
less

@see — aria-describedby.

"aria-description"?: string | undefined;

Identifies the element that provides a detailed, extended description for the object.

more
less

@see —

"aria-details"?: string | undefined;

Indicates that the element is perceivable but disabled, so it is not editable or otherwise operable.

more
less

@see —

@see —

"aria-disabled"?: Booleanish | undefined;

Indicates what functions can be performed when a dragged object is released on the drop target.

more
less

@deprecated — in ARIA 1.1

"aria-dropeffect"?: "none" | "copy" | "execute" | "link" | "move" | "popup" | undefined;

Identifies the element that provides an error message for the object.

more
less

@see —

@see —

"aria-errormessage"?: string | undefined;

Indicates whether the element, or another grouping element it controls, is currently expanded or collapsed.

"aria-expanded"?: Booleanish | undefined;

Identifies the next element (or elements) in an alternate reading order of content which, at the user's discretion, allows assistive technology to override the general default of reading in document source order.

"aria-flowto"?: string | undefined;

Indicates an element's "grabbed" state in a drag-and-drop operation.

more
less

@deprecated — in ARIA 1.1

"aria-grabbed"?: Booleanish | undefined;

Indicates the availability and type of interactive popup element, such as menu or dialog, that can be triggered by an element.

"aria-haspopup"?: boolean | "false" | "true" | "menu" | "listbox" | "tree" | "grid" | "dialog" | undefined;

Indicates whether the element is exposed to an accessibility API.

more
less

@see —

"aria-hidden"?: Booleanish | undefined;

Indicates the entered value does not conform to the format expected by the application.

more
less

@see —

"aria-invalid"?: boolean | "false" | "true" | "grammar" | "spelling" | undefined;

Indicates keyboard shortcuts that an author has implemented to activate or give focus to an element.

"aria-keyshortcuts"?: string | undefined;

Defines a string value that labels the current element.

more
less

@see —

"aria-label"?: string | undefined;

Identifies the element (or elements) that labels the current element.

more
less

@see —

"aria-labelledby"?: string | undefined;

Defines the hierarchical level of an element within a structure.

"aria-level"?: number | undefined;

Indicates that an element will be updated, and describes the types of updates the user agents, assistive technologies, and user can expect from the live region.

"aria-live"?: "off" | "assertive" | "polite" | undefined;

Indicates whether an element is modal when displayed.

"aria-modal"?: Booleanish | undefined;

Indicates whether a text box accepts multiple lines of input or only a single line.

"aria-multiline"?: Booleanish | undefined;

Indicates that the user may select more than one item from the current selectable descendants.

"aria-multiselectable"?: Booleanish | undefined;

Indicates whether the element's orientation is horizontal, vertical, or unknown/ambiguous.

"aria-orientation"?: "horizontal" | "vertical" | undefined;

Identifies an element (or elements) in order to define a visual, functional, or contextual parent/child relationship between DOM elements where the DOM hierarchy cannot be used to represent the relationship.

more
less

@see —

"aria-owns"?: string | undefined;

Defines a short hint (a word or short phrase) intended to aid the user with data entry when the control has no value. A hint could be a sample value or a brief description of the expected format.

"aria-placeholder"?: string | undefined;

Defines an element's number or position in the current set of listitems or treeitems. Not required if all elements in the set are present in the DOM.

more
less

@see —

"aria-posinset"?: number | undefined;

Indicates the current "pressed" state of toggle buttons.

more
less

@see —

@see —

"aria-pressed"?: boolean | "false" | "mixed" | "true" | undefined;

Indicates that the element is not editable, but is otherwise operable.

more
less

@see —

"aria-readonly"?: Booleanish | undefined;

Indicates what notifications the user agent will trigger when the accessibility tree within a live region is modified.

more
less

@see —

"aria-relevant"?: "additions" | "additions removals" | "additions text" | "all" | "removals" | "removals additions" | "removals text" | "text" | "text additions" | "text removals" | undefined;

Indicates that user input is required on the element before a form may be submitted.

"aria-required"?: Booleanish | undefined;

Defines a human-readable, author-localized description for the role of an element.

"aria-roledescription"?: string | undefined;

Defines the total number of rows in a table, grid, or treegrid.

more
less

@see —

"aria-rowcount"?: number | undefined;

Defines an element's row index or position with respect to the total number of rows within a table, grid, or treegrid.

more
less

@see —

@see —

"aria-rowindex"?: number | undefined;

Defines a human readable text alternative of aria-rowindex.

more
less

@see —

"aria-rowindextext"?: string | undefined;

Defines the number of rows spanned by a cell or gridcell within a table, grid, or treegrid.

more
less

@see —

@see —

"aria-rowspan"?: number | undefined;

Indicates the current "selected" state of various widgets.

more
less

@see —

@see —

"aria-selected"?: Booleanish | undefined;

Defines the number of items in the current set of listitems or treeitems. Not required if all elements in the set are present in the DOM.

more
less

@see —

"aria-setsize"?: number | undefined;

Indicates if items in a table or grid are sorted in ascending or descending order.

"aria-sort"?: "none" | "ascending" | "descending" | "other" | undefined;

Defines the maximum allowed value for a range widget.

"aria-valuemax"?: number | undefined;

Defines the minimum allowed value for a range widget.

"aria-valuemin"?: number | undefined;

Defines the current value for a range widget.

more
less

@see —

"aria-valuenow"?: number | undefined;

Defines the human readable text alternative of aria-valuenow for a range widget.

"aria-valuetext"?: string | undefined;
}
Referenced by
Unexported symbols referenced here

Booleanish

decl
type Booleanish = boolean | "true" | "false"
Referenced by

AriaRole

decl
export type AriaRole = "alert" | "alertdialog" | "application" | "article" | "banner" | "button" | "cell" | "checkbox" | "columnheader" | "combobox" | "complementary" | "contentinfo" | "definition" | "dialog" | "directory" | "document" | "feed" | "figure" | "form" | "grid" | "gridcell" | "group" | "heading" | "img" | "link" | "list" | "listbox" | "listitem" | "log" | "main" | "marquee" | "math" | "menu" | "menubar" | "menuitem" | "menuitemcheckbox" | "menuitemradio" | "navigation" | "none" | "note" | "option" | "presentation" | "progressbar" | "radio" | "radiogroup" | "region" | "row" | "rowgroup" | "rowheader" | "scrollbar" | "search" | "searchbox" | "separator" | "slider" | "spinbutton" | "status" | "switch" | "tab" | "table" | "tablist" | "tabpanel" | "term" | "textbox" | "timer" | "toolbar" | "tooltip" | "tree" | "treegrid" | "treeitem" | (string & {})
Referenced by

HTMLAttributes

decl
export interface HTMLAttributes<T> extends AriaAttributes, DOMAttributes<T> {
defaultChecked?: boolean | undefined;
defaultValue?: string | number | readonly string[] | undefined;
suppressContentEditableWarning?: boolean | undefined;
suppressHydrationWarning?: boolean | undefined;
accessKey?: string | undefined;
autoFocus?: boolean | undefined;
className?: string | undefined;
contentEditable?: Booleanish | "inherit" | "plaintext-only" | undefined;
contextMenu?: string | undefined;
dir?: string | undefined;
draggable?: Booleanish | undefined;
hidden?: boolean | undefined;
id?: string | undefined;
lang?: string | undefined;
nonce?: string | undefined;
placeholder?: string | undefined;
slot?: string | undefined;
spellCheck?: Booleanish | undefined;
style?: CSSProperties | undefined;
tabIndex?: number | undefined;
title?: string | undefined;
translate?: "yes" | "no" | undefined;
radioGroup?: string | undefined;
role?: AriaRole | undefined;
about?: string | undefined;
content?: string | undefined;
datatype?: string | undefined;
inlist?: any;
prefix?: string | undefined;
property?: string | undefined;
rel?: string | undefined;
resource?: string | undefined;
rev?: string | undefined;
typeof?: string | undefined;
vocab?: string | undefined;
autoCapitalize?: string | undefined;
autoCorrect?: string | undefined;
autoSave?: string | undefined;
color?: string | undefined;
itemProp?: string | undefined;
itemScope?: boolean | undefined;
itemType?: string | undefined;
itemID?: string | undefined;
itemRef?: string | undefined;
results?: number | undefined;
security?: string | undefined;
unselectable?: "on" | "off" | undefined;

Hints at the type of data that might be entered by the user while editing the element or its contents

more
less

@see — ://html.spec.whatwg.org/multipage/interaction.html#input-modalities:-the-inputmode-attribute

inputMode?: "none" | "text" | "tel" | "url" | "email" | "numeric" | "decimal" | "search" | undefined;

Specify that a standard HTML element should behave like a defined custom built-in element

more
less

@see — ://html.spec.whatwg.org/multipage/custom-elements.html#attr-is

is?: string | undefined;
}
Referenced by

DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_FORM_ACTIONS

decl

For internal usage only. Different release channels declare additional types of ReactNode this particular release channel accepts. App or library types should never augment this interface.

export interface DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_FORM_ACTIONS {}
Referenced by

AllHTMLAttributes

decl
export interface AllHTMLAttributes<T> extends HTMLAttributes<T> {
accept?: string | undefined;
acceptCharset?: string | undefined;
action?: string | undefined | DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_FORM_ACTIONS[keyof DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_FORM_ACTIONS];
allowFullScreen?: boolean | undefined;
allowTransparency?: boolean | undefined;
alt?: string | undefined;
as?: string | undefined;
async?: boolean | undefined;
autoComplete?: string | undefined;
autoPlay?: boolean | undefined;
capture?: boolean | "user" | "environment" | undefined;
cellPadding?: number | string | undefined;
cellSpacing?: number | string | undefined;
charSet?: string | undefined;
challenge?: string | undefined;
checked?: boolean | undefined;
cite?: string | undefined;
classID?: string | undefined;
cols?: number | undefined;
colSpan?: number | undefined;
controls?: boolean | undefined;
coords?: string | undefined;
crossOrigin?: CrossOrigin;
data?: string | undefined;
dateTime?: string | undefined;
default?: boolean | undefined;
defer?: boolean | undefined;
disabled?: boolean | undefined;
download?: any;
encType?: string | undefined;
form?: string | undefined;
formAction?: string | undefined | DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_FORM_ACTIONS[keyof DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_FORM_ACTIONS];
formEncType?: string | undefined;
formMethod?: string | undefined;
formNoValidate?: boolean | undefined;
formTarget?: string | undefined;
frameBorder?: number | string | undefined;
headers?: string | undefined;
height?: number | string | undefined;
high?: number | undefined;
href?: string | undefined;
hrefLang?: string | undefined;
htmlFor?: string | undefined;
httpEquiv?: string | undefined;
integrity?: string | undefined;
keyParams?: string | undefined;
keyType?: string | undefined;
kind?: string | undefined;
label?: string | undefined;
list?: string | undefined;
loop?: boolean | undefined;
low?: number | undefined;
manifest?: string | undefined;
marginHeight?: number | undefined;
marginWidth?: number | undefined;
max?: number | string | undefined;
maxLength?: number | undefined;
media?: string | undefined;
mediaGroup?: string | undefined;
method?: string | undefined;
min?: number | string | undefined;
minLength?: number | undefined;
multiple?: boolean | undefined;
muted?: boolean | undefined;
name?: string | undefined;
noValidate?: boolean | undefined;
open?: boolean | undefined;
optimum?: number | undefined;
pattern?: string | undefined;
placeholder?: string | undefined;
playsInline?: boolean | undefined;
poster?: string | undefined;
preload?: string | undefined;
readOnly?: boolean | undefined;
required?: boolean | undefined;
reversed?: boolean | undefined;
rows?: number | undefined;
rowSpan?: number | undefined;
sandbox?: string | undefined;
scope?: string | undefined;
scoped?: boolean | undefined;
scrolling?: string | undefined;
seamless?: boolean | undefined;
selected?: boolean | undefined;
shape?: string | undefined;
size?: number | undefined;
sizes?: string | undefined;
span?: number | undefined;
src?: string | undefined;
srcDoc?: string | undefined;
srcLang?: string | undefined;
srcSet?: string | undefined;
start?: number | undefined;
step?: number | string | undefined;
summary?: string | undefined;
target?: string | undefined;
type?: string | undefined;
useMap?: string | undefined;
value?: string | readonly string[] | number | undefined;
width?: number | string | undefined;
wmode?: string | undefined;
wrap?: string | undefined;
}
Referenced by
Unexported symbols referenced here

CrossOrigin

decl
type CrossOrigin = "anonymous" | "use-credentials" | "" | undefined
Referenced by

HTMLAttributeReferrerPolicy

decl
export type HTMLAttributeReferrerPolicy = "" | "no-referrer" | "no-referrer-when-downgrade" | "origin" | "origin-when-cross-origin" | "same-origin" | "strict-origin" | "strict-origin-when-cross-origin" | "unsafe-url"
Referenced by

HTMLAttributeAnchorTarget

decl
export type HTMLAttributeAnchorTarget = "_self" | "_blank" | "_parent" | "_top" | (string & {})
Referenced by

AnchorHTMLAttributes

decl
export interface AnchorHTMLAttributes<T> extends HTMLAttributes<T> {
download?: any;
href?: string | undefined;
hrefLang?: string | undefined;
media?: string | undefined;
ping?: string | undefined;
target?: HTMLAttributeAnchorTarget | undefined;
type?: string | undefined;
referrerPolicy?: HTMLAttributeReferrerPolicy | undefined;
}
Referenced by

AudioHTMLAttributes

decl
export interface AudioHTMLAttributes<T> extends MediaHTMLAttributes<T> {}
Referenced by

AreaHTMLAttributes

decl
export interface AreaHTMLAttributes<T> extends HTMLAttributes<T> {
alt?: string | undefined;
coords?: string | undefined;
download?: any;
href?: string | undefined;
hrefLang?: string | undefined;
media?: string | undefined;
referrerPolicy?: HTMLAttributeReferrerPolicy | undefined;
shape?: string | undefined;
target?: string | undefined;
}
Referenced by

BaseHTMLAttributes

decl
export interface BaseHTMLAttributes<T> extends HTMLAttributes<T> {
href?: string | undefined;
target?: string | undefined;
}
Referenced by

BlockquoteHTMLAttributes

decl
export interface BlockquoteHTMLAttributes<T> extends HTMLAttributes<T> {
cite?: string | undefined;
}
Referenced by

ButtonHTMLAttributes

decl
export interface ButtonHTMLAttributes<T> extends HTMLAttributes<T> {
disabled?: boolean | undefined;
form?: string | undefined;
formAction?: string | DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_FORM_ACTIONS[keyof DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_FORM_ACTIONS] | undefined;
formEncType?: string | undefined;
formMethod?: string | undefined;
formNoValidate?: boolean | undefined;
formTarget?: string | undefined;
name?: string | undefined;
type?: "submit" | "reset" | "button" | undefined;
value?: string | readonly string[] | number | undefined;
}
Referenced by

CanvasHTMLAttributes

decl
export interface CanvasHTMLAttributes<T> extends HTMLAttributes<T> {
height?: number | string | undefined;
width?: number | string | undefined;
}
Referenced by

ColHTMLAttributes

decl
export interface ColHTMLAttributes<T> extends HTMLAttributes<T> {
span?: number | undefined;
width?: number | string | undefined;
}
Referenced by

ColgroupHTMLAttributes

decl
export interface ColgroupHTMLAttributes<T> extends HTMLAttributes<T> {
span?: number | undefined;
}
Referenced by

DataHTMLAttributes

decl
export interface DataHTMLAttributes<T> extends HTMLAttributes<T> {
value?: string | readonly string[] | number | undefined;
}
Referenced by

DetailsHTMLAttributes

decl
export interface DetailsHTMLAttributes<T> extends HTMLAttributes<T> {
open?: boolean | undefined;
onToggle?: ReactEventHandler<T> | undefined;
}
Referenced by

DelHTMLAttributes

decl
export interface DelHTMLAttributes<T> extends HTMLAttributes<T> {
cite?: string | undefined;
dateTime?: string | undefined;
}
Referenced by

DialogHTMLAttributes

decl
export interface DialogHTMLAttributes<T> extends HTMLAttributes<T> {
onCancel?: ReactEventHandler<T> | undefined;
onClose?: ReactEventHandler<T> | undefined;
open?: boolean | undefined;
}
Referenced by

EmbedHTMLAttributes

decl
export interface EmbedHTMLAttributes<T> extends HTMLAttributes<T> {
height?: number | string | undefined;
src?: string | undefined;
type?: string | undefined;
width?: number | string | undefined;
}
Referenced by

FieldsetHTMLAttributes

decl
export interface FieldsetHTMLAttributes<T> extends HTMLAttributes<T> {
disabled?: boolean | undefined;
form?: string | undefined;
name?: string | undefined;
}
Referenced by

FormHTMLAttributes

decl
export interface FormHTMLAttributes<T> extends HTMLAttributes<T> {
acceptCharset?: string | undefined;
action?: string | undefined | DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_FORM_ACTIONS[keyof DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_FORM_ACTIONS];
autoComplete?: string | undefined;
encType?: string | undefined;
method?: string | undefined;
name?: string | undefined;
noValidate?: boolean | undefined;
target?: string | undefined;
}
Referenced by

HtmlHTMLAttributes

decl
export interface HtmlHTMLAttributes<T> extends HTMLAttributes<T> {
manifest?: string | undefined;
}
Referenced by

IframeHTMLAttributes

decl
export interface IframeHTMLAttributes<T> extends HTMLAttributes<T> {
allow?: string | undefined;
allowFullScreen?: boolean | undefined;
allowTransparency?: boolean | undefined;

@deprecated —

frameBorder?: number | string | undefined;
height?: number | string | undefined;
loading?: "eager" | "lazy" | undefined;

@deprecated —

marginHeight?: number | undefined;

@deprecated —

marginWidth?: number | undefined;
name?: string | undefined;
referrerPolicy?: HTMLAttributeReferrerPolicy | undefined;
sandbox?: string | undefined;

@deprecated —

scrolling?: string | undefined;
seamless?: boolean | undefined;
src?: string | undefined;
srcDoc?: string | undefined;
width?: number | string | undefined;
}
Referenced by

ImgHTMLAttributes

decl
export interface ImgHTMLAttributes<T> extends HTMLAttributes<T> {
alt?: string | undefined;
crossOrigin?: CrossOrigin;
decoding?: "async" | "auto" | "sync" | undefined;
height?: number | string | undefined;
loading?: "eager" | "lazy" | undefined;
referrerPolicy?: HTMLAttributeReferrerPolicy | undefined;
sizes?: string | undefined;
src?: string | undefined;
srcSet?: string | undefined;
useMap?: string | undefined;
width?: number | string | undefined;
}
Referenced by

InsHTMLAttributes

decl
export interface InsHTMLAttributes<T> extends HTMLAttributes<T> {
cite?: string | undefined;
dateTime?: string | undefined;
}
Referenced by

HTMLInputTypeAttribute

decl
export type HTMLInputTypeAttribute = "button" | "checkbox" | "color" | "date" | "datetime-local" | "email" | "file" | "hidden" | "image" | "month" | "number" | "password" | "radio" | "range" | "reset" | "search" | "submit" | "tel" | "text" | "time" | "url" | "week" | (string & {})
Referenced by

InputHTMLAttributes

decl
export interface InputHTMLAttributes<T> extends HTMLAttributes<T> {
accept?: string | undefined;
alt?: string | undefined;
autoComplete?: string | undefined;
capture?: boolean | "user" | "environment" | undefined;
checked?: boolean | undefined;
disabled?: boolean | undefined;
enterKeyHint?: "enter" | "done" | "go" | "next" | "previous" | "search" | "send" | undefined;
form?: string | undefined;
formAction?: string | DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_FORM_ACTIONS[keyof DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_FORM_ACTIONS] | undefined;
formEncType?: string | undefined;
formMethod?: string | undefined;
formNoValidate?: boolean | undefined;
formTarget?: string | undefined;
height?: number | string | undefined;
list?: string | undefined;
max?: number | string | undefined;
maxLength?: number | undefined;
min?: number | string | undefined;
minLength?: number | undefined;
multiple?: boolean | undefined;
name?: string | undefined;
pattern?: string | undefined;
placeholder?: string | undefined;
readOnly?: boolean | undefined;
required?: boolean | undefined;
size?: number | undefined;
src?: string | undefined;
step?: number | string | undefined;
type?: HTMLInputTypeAttribute | undefined;
value?: string | readonly string[] | number | undefined;
width?: number | string | undefined;
onChange?: ChangeEventHandler<T> | undefined;
}
Referenced by

KeygenHTMLAttributes

decl
export interface KeygenHTMLAttributes<T> extends HTMLAttributes<T> {
challenge?: string | undefined;
disabled?: boolean | undefined;
form?: string | undefined;
keyType?: string | undefined;
keyParams?: string | undefined;
name?: string | undefined;
}
Referenced by

LabelHTMLAttributes

decl
export interface LabelHTMLAttributes<T> extends HTMLAttributes<T> {
form?: string | undefined;
htmlFor?: string | undefined;
}
Referenced by

LiHTMLAttributes

decl
export interface LiHTMLAttributes<T> extends HTMLAttributes<T> {
value?: string | readonly string[] | number | undefined;
}
Referenced by

LinkHTMLAttributes

decl
export interface LinkHTMLAttributes<T> extends HTMLAttributes<T> {
as?: string | undefined;
crossOrigin?: CrossOrigin;
fetchPriority?: "high" | "low" | "auto";
href?: string | undefined;
hrefLang?: string | undefined;
integrity?: string | undefined;
media?: string | undefined;
imageSrcSet?: string | undefined;
imageSizes?: string | undefined;
referrerPolicy?: HTMLAttributeReferrerPolicy | undefined;
sizes?: string | undefined;
type?: string | undefined;
charSet?: string | undefined;
}
Referenced by

MapHTMLAttributes

decl
export interface MapHTMLAttributes<T> extends HTMLAttributes<T> {
name?: string | undefined;
}
Referenced by

MenuHTMLAttributes

decl
export interface MenuHTMLAttributes<T> extends HTMLAttributes<T> {
type?: string | undefined;
}
Referenced by

MediaHTMLAttributes

decl
export interface MediaHTMLAttributes<T> extends HTMLAttributes<T> {
autoPlay?: boolean | undefined;
controls?: boolean | undefined;
controlsList?: string | undefined;
crossOrigin?: CrossOrigin;
loop?: boolean | undefined;
mediaGroup?: string | undefined;
muted?: boolean | undefined;
playsInline?: boolean | undefined;
preload?: string | undefined;
src?: string | undefined;
}
Referenced by

MetaHTMLAttributes

decl
export interface MetaHTMLAttributes<T> extends HTMLAttributes<T> {
charSet?: string | undefined;
httpEquiv?: string | undefined;
name?: string | undefined;
media?: string | undefined;
content?: string | undefined;
}
Referenced by

MeterHTMLAttributes

decl
export interface MeterHTMLAttributes<T> extends HTMLAttributes<T> {
form?: string | undefined;
high?: number | undefined;
low?: number | undefined;
max?: number | string | undefined;
min?: number | string | undefined;
optimum?: number | undefined;
value?: string | readonly string[] | number | undefined;
}
Referenced by

QuoteHTMLAttributes

decl
export interface QuoteHTMLAttributes<T> extends HTMLAttributes<T> {
cite?: string | undefined;
}
Referenced by

ObjectHTMLAttributes

decl
export interface ObjectHTMLAttributes<T> extends HTMLAttributes<T> {
classID?: string | undefined;
data?: string | undefined;
form?: string | undefined;
height?: number | string | undefined;
name?: string | undefined;
type?: string | undefined;
useMap?: string | undefined;
width?: number | string | undefined;
wmode?: string | undefined;
}
Referenced by

OlHTMLAttributes

decl
export interface OlHTMLAttributes<T> extends HTMLAttributes<T> {
reversed?: boolean | undefined;
start?: number | undefined;
type?: "1" | "a" | "A" | "i" | "I" | undefined;
}
Referenced by

OptgroupHTMLAttributes

decl
export interface OptgroupHTMLAttributes<T> extends HTMLAttributes<T> {
disabled?: boolean | undefined;
label?: string | undefined;
}
Referenced by

OptionHTMLAttributes

decl
export interface OptionHTMLAttributes<T> extends HTMLAttributes<T> {
disabled?: boolean | undefined;
label?: string | undefined;
selected?: boolean | undefined;
value?: string | readonly string[] | number | undefined;
}
Referenced by

OutputHTMLAttributes

decl
export interface OutputHTMLAttributes<T> extends HTMLAttributes<T> {
form?: string | undefined;
htmlFor?: string | undefined;
name?: string | undefined;
}
Referenced by

ParamHTMLAttributes

decl
export interface ParamHTMLAttributes<T> extends HTMLAttributes<T> {
name?: string | undefined;
value?: string | readonly string[] | number | undefined;
}
Referenced by

ProgressHTMLAttributes

decl
export interface ProgressHTMLAttributes<T> extends HTMLAttributes<T> {
max?: number | string | undefined;
value?: string | readonly string[] | number | undefined;
}
Referenced by

SlotHTMLAttributes

decl
export interface SlotHTMLAttributes<T> extends HTMLAttributes<T> {
name?: string | undefined;
}
Referenced by

ScriptHTMLAttributes

decl
export interface ScriptHTMLAttributes<T> extends HTMLAttributes<T> {
async?: boolean | undefined;

@deprecated —

charSet?: string | undefined;
crossOrigin?: CrossOrigin;
defer?: boolean | undefined;
integrity?: string | undefined;
noModule?: boolean | undefined;
referrerPolicy?: HTMLAttributeReferrerPolicy | undefined;
src?: string | undefined;
type?: string | undefined;
}
Referenced by

SelectHTMLAttributes

decl
export interface SelectHTMLAttributes<T> extends HTMLAttributes<T> {
autoComplete?: string | undefined;
disabled?: boolean | undefined;
form?: string | undefined;
multiple?: boolean | undefined;
name?: string | undefined;
required?: boolean | undefined;
size?: number | undefined;
value?: string | readonly string[] | number | undefined;
onChange?: ChangeEventHandler<T> | undefined;
}
Referenced by

SourceHTMLAttributes

decl
export interface SourceHTMLAttributes<T> extends HTMLAttributes<T> {
height?: number | string | undefined;
media?: string | undefined;
sizes?: string | undefined;
src?: string | undefined;
srcSet?: string | undefined;
type?: string | undefined;
width?: number | string | undefined;
}
Referenced by

StyleHTMLAttributes

decl
export interface StyleHTMLAttributes<T> extends HTMLAttributes<T> {
media?: string | undefined;
scoped?: boolean | undefined;
type?: string | undefined;
}
Referenced by

TableHTMLAttributes

decl
export interface TableHTMLAttributes<T> extends HTMLAttributes<T> {
align?: "left" | "center" | "right" | undefined;
bgcolor?: string | undefined;
border?: number | undefined;
cellPadding?: number | string | undefined;
cellSpacing?: number | string | undefined;
frame?: boolean | undefined;
rules?: "none" | "groups" | "rows" | "columns" | "all" | undefined;
summary?: string | undefined;
width?: number | string | undefined;
}
Referenced by

TextareaHTMLAttributes

decl
export interface TextareaHTMLAttributes<T> extends HTMLAttributes<T> {
autoComplete?: string | undefined;
cols?: number | undefined;
dirName?: string | undefined;
disabled?: boolean | undefined;
form?: string | undefined;
maxLength?: number | undefined;
minLength?: number | undefined;
name?: string | undefined;
placeholder?: string | undefined;
readOnly?: boolean | undefined;
required?: boolean | undefined;
rows?: number | undefined;
value?: string | readonly string[] | number | undefined;
wrap?: string | undefined;
onChange?: ChangeEventHandler<T> | undefined;
}
Referenced by

TdHTMLAttributes

decl
export interface TdHTMLAttributes<T> extends HTMLAttributes<T> {
align?: "left" | "center" | "right" | "justify" | "char" | undefined;
colSpan?: number | undefined;
headers?: string | undefined;
rowSpan?: number | undefined;
scope?: string | undefined;
abbr?: string | undefined;
height?: number | string | undefined;
width?: number | string | undefined;
valign?: "top" | "middle" | "bottom" | "baseline" | undefined;
}
Referenced by

ThHTMLAttributes

decl
export interface ThHTMLAttributes<T> extends HTMLAttributes<T> {
align?: "left" | "center" | "right" | "justify" | "char" | undefined;
colSpan?: number | undefined;
headers?: string | undefined;
rowSpan?: number | undefined;
scope?: string | undefined;
abbr?: string | undefined;
}
Referenced by

TimeHTMLAttributes

decl
export interface TimeHTMLAttributes<T> extends HTMLAttributes<T> {
dateTime?: string | undefined;
}
Referenced by

TrackHTMLAttributes

decl
export interface TrackHTMLAttributes<T> extends HTMLAttributes<T> {
default?: boolean | undefined;
kind?: string | undefined;
label?: string | undefined;
src?: string | undefined;
srcLang?: string | undefined;
}
Referenced by

VideoHTMLAttributes

decl
export interface VideoHTMLAttributes<T> extends MediaHTMLAttributes<T> {
height?: number | string | undefined;
playsInline?: boolean | undefined;
poster?: string | undefined;
width?: number | string | undefined;
disablePictureInPicture?: boolean | undefined;
disableRemotePlayback?: boolean | undefined;
}
Referenced by

SVGAttributes

decl
export interface SVGAttributes<T> extends AriaAttributes, DOMAttributes<T> {
suppressHydrationWarning?: boolean | undefined;
className?: string | undefined;
color?: string | undefined;
height?: number | string | undefined;
id?: string | undefined;
lang?: string | undefined;
max?: number | string | undefined;
media?: string | undefined;
method?: string | undefined;
min?: number | string | undefined;
name?: string | undefined;
style?: CSSProperties | undefined;
target?: string | undefined;
type?: string | undefined;
width?: number | string | undefined;
role?: AriaRole | undefined;
tabIndex?: number | undefined;
crossOrigin?: CrossOrigin;
accentHeight?: number | string | undefined;
accumulate?: "none" | "sum" | undefined;
additive?: "replace" | "sum" | undefined;
alignmentBaseline?: "auto" | "baseline" | "before-edge" | "text-before-edge" | "middle" | "central" | "after-edge" | "text-after-edge" | "ideographic" | "alphabetic" | "hanging" | "mathematical" | "inherit" | undefined;
allowReorder?: "no" | "yes" | undefined;
alphabetic?: number | string | undefined;
amplitude?: number | string | undefined;
arabicForm?: "initial" | "medial" | "terminal" | "isolated" | undefined;
ascent?: number | string | undefined;
attributeName?: string | undefined;
attributeType?: string | undefined;
autoReverse?: Booleanish | undefined;
azimuth?: number | string | undefined;
baseFrequency?: number | string | undefined;
baselineShift?: number | string | undefined;
baseProfile?: number | string | undefined;
bbox?: number | string | undefined;
begin?: number | string | undefined;
bias?: number | string | undefined;
by?: number | string | undefined;
calcMode?: number | string | undefined;
capHeight?: number | string | undefined;
clip?: number | string | undefined;
clipPath?: string | undefined;
clipPathUnits?: number | string | undefined;
clipRule?: number | string | undefined;
colorInterpolation?: number | string | undefined;
colorInterpolationFilters?: "auto" | "sRGB" | "linearRGB" | "inherit" | undefined;
colorProfile?: number | string | undefined;
colorRendering?: number | string | undefined;
contentScriptType?: number | string | undefined;
contentStyleType?: number | string | undefined;
cursor?: number | string | undefined;
cx?: number | string | undefined;
cy?: number | string | undefined;
d?: string | undefined;
decelerate?: number | string | undefined;
descent?: number | string | undefined;
diffuseConstant?: number | string | undefined;
direction?: number | string | undefined;
display?: number | string | undefined;
divisor?: number | string | undefined;
dominantBaseline?: number | string | undefined;
dur?: number | string | undefined;
dx?: number | string | undefined;
dy?: number | string | undefined;
edgeMode?: number | string | undefined;
elevation?: number | string | undefined;
enableBackground?: number | string | undefined;
end?: number | string | undefined;
exponent?: number | string | undefined;
externalResourcesRequired?: Booleanish | undefined;
fill?: string | undefined;
fillOpacity?: number | string | undefined;
fillRule?: "nonzero" | "evenodd" | "inherit" | undefined;
filter?: string | undefined;
filterRes?: number | string | undefined;
filterUnits?: number | string | undefined;
floodColor?: number | string | undefined;
floodOpacity?: number | string | undefined;
focusable?: Booleanish | "auto" | undefined;
fontFamily?: string | undefined;
fontSize?: number | string | undefined;
fontSizeAdjust?: number | string | undefined;
fontStretch?: number | string | undefined;
fontStyle?: number | string | undefined;
fontVariant?: number | string | undefined;
fontWeight?: number | string | undefined;
format?: number | string | undefined;
fr?: number | string | undefined;
from?: number | string | undefined;
fx?: number | string | undefined;
fy?: number | string | undefined;
g1?: number | string | undefined;
g2?: number | string | undefined;
glyphName?: number | string | undefined;
glyphOrientationHorizontal?: number | string | undefined;
glyphOrientationVertical?: number | string | undefined;
glyphRef?: number | string | undefined;
gradientTransform?: string | undefined;
gradientUnits?: string | undefined;
hanging?: number | string | undefined;
horizAdvX?: number | string | undefined;
horizOriginX?: number | string | undefined;
href?: string | undefined;
ideographic?: number | string | undefined;
imageRendering?: number | string | undefined;
in2?: number | string | undefined;
in?: string | undefined;
intercept?: number | string | undefined;
k1?: number | string | undefined;
k2?: number | string | undefined;
k3?: number | string | undefined;
k4?: number | string | undefined;
k?: number | string | undefined;
kernelMatrix?: number | string | undefined;
kernelUnitLength?: number | string | undefined;
kerning?: number | string | undefined;
keyPoints?: number | string | undefined;
keySplines?: number | string | undefined;
keyTimes?: number | string | undefined;
lengthAdjust?: number | string | undefined;
letterSpacing?: number | string | undefined;
lightingColor?: number | string | undefined;
limitingConeAngle?: number | string | undefined;
local?: number | string | undefined;
markerEnd?: string | undefined;
markerHeight?: number | string | undefined;
markerMid?: string | undefined;
markerStart?: string | undefined;
markerUnits?: number | string | undefined;
markerWidth?: number | string | undefined;
mask?: string | undefined;
maskContentUnits?: number | string | undefined;
maskUnits?: number | string | undefined;
mathematical?: number | string | undefined;
mode?: number | string | undefined;
numOctaves?: number | string | undefined;
offset?: number | string | undefined;
opacity?: number | string | undefined;
operator?: number | string | undefined;
order?: number | string | undefined;
orient?: number | string | undefined;
orientation?: number | string | undefined;
origin?: number | string | undefined;
overflow?: number | string | undefined;
overlinePosition?: number | string | undefined;
overlineThickness?: number | string | undefined;
paintOrder?: number | string | undefined;
panose1?: number | string | undefined;
path?: string | undefined;
pathLength?: number | string | undefined;
patternContentUnits?: string | undefined;
patternTransform?: number | string | undefined;
patternUnits?: string | undefined;
pointerEvents?: number | string | undefined;
points?: string | undefined;
pointsAtX?: number | string | undefined;
pointsAtY?: number | string | undefined;
pointsAtZ?: number | string | undefined;
preserveAlpha?: Booleanish | undefined;
preserveAspectRatio?: string | undefined;
primitiveUnits?: number | string | undefined;
r?: number | string | undefined;
radius?: number | string | undefined;
refX?: number | string | undefined;
refY?: number | string | undefined;
renderingIntent?: number | string | undefined;
repeatCount?: number | string | undefined;
repeatDur?: number | string | undefined;
requiredExtensions?: number | string | undefined;
requiredFeatures?: number | string | undefined;
restart?: number | string | undefined;
result?: string | undefined;
rotate?: number | string | undefined;
rx?: number | string | undefined;
ry?: number | string | undefined;
scale?: number | string | undefined;
seed?: number | string | undefined;
shapeRendering?: number | string | undefined;
slope?: number | string | undefined;
spacing?: number | string | undefined;
specularConstant?: number | string | undefined;
specularExponent?: number | string | undefined;
speed?: number | string | undefined;
spreadMethod?: string | undefined;
startOffset?: number | string | undefined;
stdDeviation?: number | string | undefined;
stemh?: number | string | undefined;
stemv?: number | string | undefined;
stitchTiles?: number | string | undefined;
stopColor?: string | undefined;
stopOpacity?: number | string | undefined;
strikethroughPosition?: number | string | undefined;
strikethroughThickness?: number | string | undefined;
string?: number | string | undefined;
stroke?: string | undefined;
strokeDasharray?: string | number | undefined;
strokeDashoffset?: string | number | undefined;
strokeLinecap?: "butt" | "round" | "square" | "inherit" | undefined;
strokeLinejoin?: "miter" | "round" | "bevel" | "inherit" | undefined;
strokeMiterlimit?: number | string | undefined;
strokeOpacity?: number | string | undefined;
strokeWidth?: number | string | undefined;
surfaceScale?: number | string | undefined;
systemLanguage?: number | string | undefined;
tableValues?: number | string | undefined;
targetX?: number | string | undefined;
targetY?: number | string | undefined;
textAnchor?: string | undefined;
textDecoration?: number | string | undefined;
textLength?: number | string | undefined;
textRendering?: number | string | undefined;
to?: number | string | undefined;
transform?: string | undefined;
u1?: number | string | undefined;
u2?: number | string | undefined;
underlinePosition?: number | string | undefined;
underlineThickness?: number | string | undefined;
unicode?: number | string | undefined;
unicodeBidi?: number | string | undefined;
unicodeRange?: number | string | undefined;
unitsPerEm?: number | string | undefined;
vAlphabetic?: number | string | undefined;
values?: string | undefined;
vectorEffect?: number | string | undefined;
version?: string | undefined;
vertAdvY?: number | string | undefined;
vertOriginX?: number | string | undefined;
vertOriginY?: number | string | undefined;
vHanging?: number | string | undefined;
vIdeographic?: number | string | undefined;
viewBox?: string | undefined;
viewTarget?: number | string | undefined;
visibility?: number | string | undefined;
vMathematical?: number | string | undefined;
widths?: number | string | undefined;
wordSpacing?: number | string | undefined;
writingMode?: number | string | undefined;
x1?: number | string | undefined;
x2?: number | string | undefined;
x?: number | string | undefined;
xChannelSelector?: string | undefined;
xHeight?: number | string | undefined;
xlinkActuate?: string | undefined;
xlinkArcrole?: string | undefined;
xlinkHref?: string | undefined;
xlinkRole?: string | undefined;
xlinkShow?: string | undefined;
xlinkTitle?: string | undefined;
xlinkType?: string | undefined;
xmlBase?: string | undefined;
xmlLang?: string | undefined;
xmlns?: string | undefined;
xmlnsXlink?: string | undefined;
xmlSpace?: string | undefined;
y1?: number | string | undefined;
y2?: number | string | undefined;
y?: number | string | undefined;
yChannelSelector?: string | undefined;
z?: number | string | undefined;
zoomAndPan?: string | undefined;
}
Referenced by

WebViewHTMLAttributes

decl
export interface WebViewHTMLAttributes<T> extends HTMLAttributes<T> {
allowFullScreen?: boolean | undefined;
allowpopups?: boolean | undefined;
autosize?: boolean | undefined;
blinkfeatures?: string | undefined;
disableblinkfeatures?: string | undefined;
disableguestresize?: boolean | undefined;
disablewebsecurity?: boolean | undefined;
guestinstance?: string | undefined;
httpreferrer?: string | undefined;
nodeintegration?: boolean | undefined;
partition?: string | undefined;
plugins?: boolean | undefined;
preload?: string | undefined;
src?: string | undefined;
useragent?: string | undefined;
webpreferences?: string | undefined;
}
Referenced by

ReactHTML

decl
export interface ReactHTML {
a: DetailedHTMLFactory<AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>;
abbr: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
address: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
area: DetailedHTMLFactory<AreaHTMLAttributes<HTMLAreaElement>, HTMLAreaElement>;
article: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
aside: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
audio: DetailedHTMLFactory<AudioHTMLAttributes<HTMLAudioElement>, HTMLAudioElement>;
b: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
base: DetailedHTMLFactory<BaseHTMLAttributes<HTMLBaseElement>, HTMLBaseElement>;
bdi: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
bdo: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
big: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
blockquote: DetailedHTMLFactory<BlockquoteHTMLAttributes<HTMLQuoteElement>, HTMLQuoteElement>;
body: DetailedHTMLFactory<HTMLAttributes<HTMLBodyElement>, HTMLBodyElement>;
br: DetailedHTMLFactory<HTMLAttributes<HTMLBRElement>, HTMLBRElement>;
button: DetailedHTMLFactory<ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>;
canvas: DetailedHTMLFactory<CanvasHTMLAttributes<HTMLCanvasElement>, HTMLCanvasElement>;
caption: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
center: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
cite: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
code: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
col: DetailedHTMLFactory<ColHTMLAttributes<HTMLTableColElement>, HTMLTableColElement>;
colgroup: DetailedHTMLFactory<ColgroupHTMLAttributes<HTMLTableColElement>, HTMLTableColElement>;
data: DetailedHTMLFactory<DataHTMLAttributes<HTMLDataElement>, HTMLDataElement>;
datalist: DetailedHTMLFactory<HTMLAttributes<HTMLDataListElement>, HTMLDataListElement>;
dd: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
del: DetailedHTMLFactory<DelHTMLAttributes<HTMLModElement>, HTMLModElement>;
details: DetailedHTMLFactory<DetailsHTMLAttributes<HTMLDetailsElement>, HTMLDetailsElement>;
dfn: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
dialog: DetailedHTMLFactory<DialogHTMLAttributes<HTMLDialogElement>, HTMLDialogElement>;
div: DetailedHTMLFactory<HTMLAttributes<HTMLDivElement>, HTMLDivElement>;
dl: DetailedHTMLFactory<HTMLAttributes<HTMLDListElement>, HTMLDListElement>;
dt: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
em: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
embed: DetailedHTMLFactory<EmbedHTMLAttributes<HTMLEmbedElement>, HTMLEmbedElement>;
fieldset: DetailedHTMLFactory<FieldsetHTMLAttributes<HTMLFieldSetElement>, HTMLFieldSetElement>;
figcaption: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
figure: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
footer: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
form: DetailedHTMLFactory<FormHTMLAttributes<HTMLFormElement>, HTMLFormElement>;
h1: DetailedHTMLFactory<HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>;
h2: DetailedHTMLFactory<HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>;
h3: DetailedHTMLFactory<HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>;
h4: DetailedHTMLFactory<HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>;
h5: DetailedHTMLFactory<HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>;
h6: DetailedHTMLFactory<HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>;
head: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLHeadElement>;
header: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
hgroup: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
hr: DetailedHTMLFactory<HTMLAttributes<HTMLHRElement>, HTMLHRElement>;
html: DetailedHTMLFactory<HtmlHTMLAttributes<HTMLHtmlElement>, HTMLHtmlElement>;
i: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
iframe: DetailedHTMLFactory<IframeHTMLAttributes<HTMLIFrameElement>, HTMLIFrameElement>;
img: DetailedHTMLFactory<ImgHTMLAttributes<HTMLImageElement>, HTMLImageElement>;
input: DetailedHTMLFactory<InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>;
ins: DetailedHTMLFactory<InsHTMLAttributes<HTMLModElement>, HTMLModElement>;
kbd: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
keygen: DetailedHTMLFactory<KeygenHTMLAttributes<HTMLElement>, HTMLElement>;
label: DetailedHTMLFactory<LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>;
legend: DetailedHTMLFactory<HTMLAttributes<HTMLLegendElement>, HTMLLegendElement>;
li: DetailedHTMLFactory<LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>;
link: DetailedHTMLFactory<LinkHTMLAttributes<HTMLLinkElement>, HTMLLinkElement>;
main: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
map: DetailedHTMLFactory<MapHTMLAttributes<HTMLMapElement>, HTMLMapElement>;
mark: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
menu: DetailedHTMLFactory<MenuHTMLAttributes<HTMLElement>, HTMLElement>;
menuitem: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
meta: DetailedHTMLFactory<MetaHTMLAttributes<HTMLMetaElement>, HTMLMetaElement>;
meter: DetailedHTMLFactory<MeterHTMLAttributes<HTMLMeterElement>, HTMLMeterElement>;
nav: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
noscript: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
object: DetailedHTMLFactory<ObjectHTMLAttributes<HTMLObjectElement>, HTMLObjectElement>;
ol: DetailedHTMLFactory<OlHTMLAttributes<HTMLOListElement>, HTMLOListElement>;
optgroup: DetailedHTMLFactory<OptgroupHTMLAttributes<HTMLOptGroupElement>, HTMLOptGroupElement>;
option: DetailedHTMLFactory<OptionHTMLAttributes<HTMLOptionElement>, HTMLOptionElement>;
output: DetailedHTMLFactory<OutputHTMLAttributes<HTMLOutputElement>, HTMLOutputElement>;
p: DetailedHTMLFactory<HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>;
param: DetailedHTMLFactory<ParamHTMLAttributes<HTMLParamElement>, HTMLParamElement>;
picture: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
pre: DetailedHTMLFactory<HTMLAttributes<HTMLPreElement>, HTMLPreElement>;
progress: DetailedHTMLFactory<ProgressHTMLAttributes<HTMLProgressElement>, HTMLProgressElement>;
q: DetailedHTMLFactory<QuoteHTMLAttributes<HTMLQuoteElement>, HTMLQuoteElement>;
rp: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
rt: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
ruby: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
s: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
samp: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
search: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
slot: DetailedHTMLFactory<SlotHTMLAttributes<HTMLSlotElement>, HTMLSlotElement>;
script: DetailedHTMLFactory<ScriptHTMLAttributes<HTMLScriptElement>, HTMLScriptElement>;
section: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
select: DetailedHTMLFactory<SelectHTMLAttributes<HTMLSelectElement>, HTMLSelectElement>;
small: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
source: DetailedHTMLFactory<SourceHTMLAttributes<HTMLSourceElement>, HTMLSourceElement>;
span: DetailedHTMLFactory<HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>;
strong: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
style: DetailedHTMLFactory<StyleHTMLAttributes<HTMLStyleElement>, HTMLStyleElement>;
sub: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
summary: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
sup: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
table: DetailedHTMLFactory<TableHTMLAttributes<HTMLTableElement>, HTMLTableElement>;
template: DetailedHTMLFactory<HTMLAttributes<HTMLTemplateElement>, HTMLTemplateElement>;
tbody: DetailedHTMLFactory<HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>;
td: DetailedHTMLFactory<TdHTMLAttributes<HTMLTableDataCellElement>, HTMLTableDataCellElement>;
textarea: DetailedHTMLFactory<TextareaHTMLAttributes<HTMLTextAreaElement>, HTMLTextAreaElement>;
tfoot: DetailedHTMLFactory<HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>;
th: DetailedHTMLFactory<ThHTMLAttributes<HTMLTableHeaderCellElement>, HTMLTableHeaderCellElement>;
thead: DetailedHTMLFactory<HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>;
time: DetailedHTMLFactory<TimeHTMLAttributes<HTMLTimeElement>, HTMLTimeElement>;
title: DetailedHTMLFactory<HTMLAttributes<HTMLTitleElement>, HTMLTitleElement>;
tr: DetailedHTMLFactory<HTMLAttributes<HTMLTableRowElement>, HTMLTableRowElement>;
track: DetailedHTMLFactory<TrackHTMLAttributes<HTMLTrackElement>, HTMLTrackElement>;
u: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
ul: DetailedHTMLFactory<HTMLAttributes<HTMLUListElement>, HTMLUListElement>;
"var": DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
video: DetailedHTMLFactory<VideoHTMLAttributes<HTMLVideoElement>, HTMLVideoElement>;
wbr: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
webview: DetailedHTMLFactory<WebViewHTMLAttributes<HTMLWebViewElement>, HTMLWebViewElement>;
}
Referenced by
Unexported symbols referenced here

HTMLWebViewElement

decl
interface HTMLWebViewElement extends HTMLElement {}
Referenced by

ReactSVG

decl
export interface ReactSVG {
animate: SVGFactory;
circle: SVGFactory;
clipPath: SVGFactory;
defs: SVGFactory;
desc: SVGFactory;
ellipse: SVGFactory;
feBlend: SVGFactory;
feColorMatrix: SVGFactory;
feComponentTransfer: SVGFactory;
feComposite: SVGFactory;
feConvolveMatrix: SVGFactory;
feDiffuseLighting: SVGFactory;
feDisplacementMap: SVGFactory;
feDistantLight: SVGFactory;
feDropShadow: SVGFactory;
feFlood: SVGFactory;
feFuncA: SVGFactory;
feFuncB: SVGFactory;
feFuncG: SVGFactory;
feFuncR: SVGFactory;
feGaussianBlur: SVGFactory;
feImage: SVGFactory;
feMerge: SVGFactory;
feMergeNode: SVGFactory;
feMorphology: SVGFactory;
feOffset: SVGFactory;
fePointLight: SVGFactory;
feSpecularLighting: SVGFactory;
feSpotLight: SVGFactory;
feTile: SVGFactory;
feTurbulence: SVGFactory;
filter: SVGFactory;
foreignObject: SVGFactory;
g: SVGFactory;
image: SVGFactory;
line: SVGFactory;
linearGradient: SVGFactory;
marker: SVGFactory;
mask: SVGFactory;
metadata: SVGFactory;
path: SVGFactory;
pattern: SVGFactory;
polygon: SVGFactory;
polyline: SVGFactory;
radialGradient: SVGFactory;
rect: SVGFactory;
stop: SVGFactory;
svg: SVGFactory;
switch: SVGFactory;
symbol: SVGFactory;
text: SVGFactory;
textPath: SVGFactory;
tspan: SVGFactory;
use: SVGFactory;
view: SVGFactory;
}
Referenced by

ReactDOM

decl
export interface ReactDOM extends ReactHTML, ReactSVG {}

Validator

decl
export type Validator<T> = import("prop-types").Validator<T>
Referenced by

Requireable

decl
export type Requireable<T> = import("prop-types").Requireable<T>

WeakValidationMap

decl
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]>;
}
Referenced by

ReactPropTypes

decl
export interface ReactPropTypes {
any: typeof import("prop-types").any;
array: typeof import("prop-types").array;
bool: typeof import("prop-types").bool;
func: typeof import("prop-types").func;
number: typeof import("prop-types").number;
object: typeof import("prop-types").object;
string: typeof import("prop-types").string;
node: typeof import("prop-types").node;
element: typeof import("prop-types").element;
instanceOf: typeof import("prop-types").instanceOf;
oneOf: typeof import("prop-types").oneOf;
oneOfType: typeof import("prop-types").oneOfType;
arrayOf: typeof import("prop-types").arrayOf;
objectOf: typeof import("prop-types").objectOf;
shape: typeof import("prop-types").shape;
exact: typeof import("prop-types").exact;
}

ReactChildren

decl

@deprecated — - Use typeof React.Children instead.

export interface ReactChildren {
map<T, C>(children: C | readonly C[], fn: (child: C, index: number) => T): C extends null | undefined ? C : Exclude<T, boolean | null | undefined>[];
forEach<C>(children: C | readonly C[], fn: (child: C, index: number) => void): void;
count(children: any): number;
only<C>(children: C): C extends any[] ? never : C;
toArray(children: ReactNode | ReactNode[]): Exclude<ReactNode, boolean | null | undefined>[];
}

AbstractView

decl
export interface AbstractView {
styleMedia: StyleMedia;
document: Document;
}
Referenced by

Touch

decl
export interface Touch {
identifier: number;
target: EventTarget;
screenX: number;
screenY: number;
clientX: number;
clientY: number;
pageX: number;
pageY: number;
}
Referenced by

TouchList

decl
export interface TouchList {
[key: number]: Touch;
length: number;
item(index: number): Touch;
identifiedTouch(identifier: number): Touch;
}
Referenced by

ErrorInfo

decl
export interface ErrorInfo {

Captures which component contained the exception, and its ancestors.

componentStack?: string | null;
digest?: string | null;
}
Referenced by

JSX

decl
export namespace JSX {

ElementType

decl
export type ElementType = GlobalJSXElementType
Unexported symbols referenced here

GlobalJSXElementType

decl
type GlobalJSXElementType = ElementType
Referenced by

ElementType

decl
type ElementType = string | JSXElementConstructor<any>
Referenced by

Element

decl
export interface Element extends GlobalJSXElement {}
Unexported symbols referenced here

GlobalJSXElement

decl
interface GlobalJSXElement extends Element {}
Referenced by

Element

decl
interface Element extends ReactElement<any, any> {}
Referenced by

ElementClass

decl
export interface ElementClass extends GlobalJSXElementClass {}
Unexported symbols referenced here

GlobalJSXElementClass

decl
interface GlobalJSXElementClass extends ElementClass {}
Referenced by

ElementClass

decl
interface ElementClass extends Component<any> {
render(): ReactNode;
}
Referenced by

ElementAttributesProperty

decl
export interface ElementAttributesProperty extends GlobalJSXElementAttributesProperty {}
Unexported symbols referenced here

GlobalJSXElementAttributesProperty

decl
interface GlobalJSXElementAttributesProperty extends ElementAttributesProperty {}
Referenced by

ElementAttributesProperty

decl
interface ElementAttributesProperty {
props: {};
}
Referenced by

ElementChildrenAttribute

decl
export interface ElementChildrenAttribute extends GlobalJSXElementChildrenAttribute {}
Unexported symbols referenced here

GlobalJSXElementChildrenAttribute

decl
interface GlobalJSXElementChildrenAttribute extends ElementChildrenAttribute {}
Referenced by

ElementChildrenAttribute

decl
interface ElementChildrenAttribute {
children: {};
}
Referenced by

LibraryManagedAttributes

decl
export type LibraryManagedAttributes<C, P> = GlobalJSXLibraryManagedAttributes<C, P>
Unexported symbols referenced here

GlobalJSXLibraryManagedAttributes

decl
type GlobalJSXLibraryManagedAttributes<C, P> = LibraryManagedAttributes<C, P>
Referenced by

LibraryManagedAttributes

decl
type LibraryManagedAttributes<C, P> = C extends MemoExoticComponent<infer T> | LazyExoticComponent<infer T> ? T extends MemoExoticComponent<infer U> | LazyExoticComponent<infer U> ? ReactManagedAttributes<U, P> : ReactManagedAttributes<T, P> : ReactManagedAttributes<C, P>
Referenced by

ReactManagedAttributes

decl
type ReactManagedAttributes<C, P> = C extends {
propTypes: infer T;
defaultProps: infer D;
} ? Defaultize<MergePropTypes<P, import("prop-types").InferProps<T>>, D> : C extends {
propTypes: infer T;
} ? MergePropTypes<P, import("prop-types").InferProps<T>> : C extends {
defaultProps: infer D;
} ? Defaultize<P, D> : P
Referenced by

Defaultize

decl
type Defaultize<P, D> = P extends any ? string extends keyof P ? P : Pick<P, Exclude<keyof P, keyof D>> & InexactPartial<Pick<P, Extract<keyof P, keyof D>>> & InexactPartial<Pick<D, Exclude<keyof D, keyof P>>> : never
Referenced by

MergePropTypes

decl
type MergePropTypes<P, T> = P extends any ? IsExactlyAny<P> extends true ? T : string extends keyof P ? P : Pick<P, NotExactlyAnyPropertyKeys<P>> & Pick<T, Exclude<keyof T, NotExactlyAnyPropertyKeys<P>>> & Pick<P, Exclude<keyof P, keyof T>> : never
Referenced by

IsExactlyAny

decl
type IsExactlyAny<T> = boolean extends (T extends never ? true : false) ? true : false
Referenced by

NotExactlyAnyPropertyKeys

decl
type NotExactlyAnyPropertyKeys<T> = Exclude<keyof T, ExactlyAnyPropertyKeys<T>>
Referenced by

ExactlyAnyPropertyKeys

decl
type ExactlyAnyPropertyKeys<T> = {
[K in keyof T]: IsExactlyAny<T[K]> extends true ? K : never;
}[keyof T]
Referenced by

InexactPartial

decl
type InexactPartial<T> = {
[K in keyof T]?: T[K] | undefined;
}
Referenced by

IntrinsicAttributes

decl
export interface IntrinsicAttributes extends GlobalJSXIntrinsicAttributes {}
Unexported symbols referenced here

GlobalJSXIntrinsicAttributes

decl
interface GlobalJSXIntrinsicAttributes extends IntrinsicAttributes {}
Referenced by

IntrinsicAttributes

decl
interface IntrinsicAttributes extends Attributes {}
Referenced by

IntrinsicClassAttributes

decl
export interface IntrinsicClassAttributes<T> extends GlobalJSXIntrinsicClassAttributes<T> {}
Unexported symbols referenced here

GlobalJSXIntrinsicClassAttributes

decl
interface GlobalJSXIntrinsicClassAttributes<T> extends IntrinsicClassAttributes<T> {}
Referenced by

IntrinsicClassAttributes

decl
interface IntrinsicClassAttributes<T> extends ClassAttributes<T> {}
Referenced by

IntrinsicElements

decl
export interface IntrinsicElements extends GlobalJSXIntrinsicElements {}
Referenced by
Unexported symbols referenced here

GlobalJSXIntrinsicElements

decl
interface GlobalJSXIntrinsicElements extends IntrinsicElements {}
Referenced by

IntrinsicElements

decl
interface IntrinsicElements {
a: DetailedHTMLProps<AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>;
abbr: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
address: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
area: DetailedHTMLProps<AreaHTMLAttributes<HTMLAreaElement>, HTMLAreaElement>;
article: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
aside: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
audio: DetailedHTMLProps<AudioHTMLAttributes<HTMLAudioElement>, HTMLAudioElement>;
b: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
base: DetailedHTMLProps<BaseHTMLAttributes<HTMLBaseElement>, HTMLBaseElement>;
bdi: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
bdo: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
big: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
blockquote: DetailedHTMLProps<BlockquoteHTMLAttributes<HTMLQuoteElement>, HTMLQuoteElement>;
body: DetailedHTMLProps<HTMLAttributes<HTMLBodyElement>, HTMLBodyElement>;
br: DetailedHTMLProps<HTMLAttributes<HTMLBRElement>, HTMLBRElement>;
button: DetailedHTMLProps<ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>;
canvas: DetailedHTMLProps<CanvasHTMLAttributes<HTMLCanvasElement>, HTMLCanvasElement>;
caption: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
center: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
cite: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
code: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
col: DetailedHTMLProps<ColHTMLAttributes<HTMLTableColElement>, HTMLTableColElement>;
colgroup: DetailedHTMLProps<ColgroupHTMLAttributes<HTMLTableColElement>, HTMLTableColElement>;
data: DetailedHTMLProps<DataHTMLAttributes<HTMLDataElement>, HTMLDataElement>;
datalist: DetailedHTMLProps<HTMLAttributes<HTMLDataListElement>, HTMLDataListElement>;
dd: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
del: DetailedHTMLProps<DelHTMLAttributes<HTMLModElement>, HTMLModElement>;
details: DetailedHTMLProps<DetailsHTMLAttributes<HTMLDetailsElement>, HTMLDetailsElement>;
dfn: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
dialog: DetailedHTMLProps<DialogHTMLAttributes<HTMLDialogElement>, HTMLDialogElement>;
div: DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>;
dl: DetailedHTMLProps<HTMLAttributes<HTMLDListElement>, HTMLDListElement>;
dt: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
em: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
embed: DetailedHTMLProps<EmbedHTMLAttributes<HTMLEmbedElement>, HTMLEmbedElement>;
fieldset: DetailedHTMLProps<FieldsetHTMLAttributes<HTMLFieldSetElement>, HTMLFieldSetElement>;
figcaption: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
figure: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
footer: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
form: DetailedHTMLProps<FormHTMLAttributes<HTMLFormElement>, HTMLFormElement>;
h1: DetailedHTMLProps<HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>;
h2: DetailedHTMLProps<HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>;
h3: DetailedHTMLProps<HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>;
h4: DetailedHTMLProps<HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>;
h5: DetailedHTMLProps<HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>;
h6: DetailedHTMLProps<HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>;
head: DetailedHTMLProps<HTMLAttributes<HTMLHeadElement>, HTMLHeadElement>;
header: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
hgroup: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
hr: DetailedHTMLProps<HTMLAttributes<HTMLHRElement>, HTMLHRElement>;
html: DetailedHTMLProps<HtmlHTMLAttributes<HTMLHtmlElement>, HTMLHtmlElement>;
i: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
iframe: DetailedHTMLProps<IframeHTMLAttributes<HTMLIFrameElement>, HTMLIFrameElement>;
img: DetailedHTMLProps<ImgHTMLAttributes<HTMLImageElement>, HTMLImageElement>;
input: DetailedHTMLProps<InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>;
ins: DetailedHTMLProps<InsHTMLAttributes<HTMLModElement>, HTMLModElement>;
kbd: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
keygen: DetailedHTMLProps<KeygenHTMLAttributes<HTMLElement>, HTMLElement>;
label: DetailedHTMLProps<LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>;
legend: DetailedHTMLProps<HTMLAttributes<HTMLLegendElement>, HTMLLegendElement>;
li: DetailedHTMLProps<LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>;
link: DetailedHTMLProps<LinkHTMLAttributes<HTMLLinkElement>, HTMLLinkElement>;
main: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
map: DetailedHTMLProps<MapHTMLAttributes<HTMLMapElement>, HTMLMapElement>;
mark: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
menu: DetailedHTMLProps<MenuHTMLAttributes<HTMLElement>, HTMLElement>;
menuitem: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
meta: DetailedHTMLProps<MetaHTMLAttributes<HTMLMetaElement>, HTMLMetaElement>;
meter: DetailedHTMLProps<MeterHTMLAttributes<HTMLMeterElement>, HTMLMeterElement>;
nav: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
noindex: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
noscript: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
object: DetailedHTMLProps<ObjectHTMLAttributes<HTMLObjectElement>, HTMLObjectElement>;
ol: DetailedHTMLProps<OlHTMLAttributes<HTMLOListElement>, HTMLOListElement>;
optgroup: DetailedHTMLProps<OptgroupHTMLAttributes<HTMLOptGroupElement>, HTMLOptGroupElement>;
option: DetailedHTMLProps<OptionHTMLAttributes<HTMLOptionElement>, HTMLOptionElement>;
output: DetailedHTMLProps<OutputHTMLAttributes<HTMLOutputElement>, HTMLOutputElement>;
p: DetailedHTMLProps<HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>;
param: DetailedHTMLProps<ParamHTMLAttributes<HTMLParamElement>, HTMLParamElement>;
picture: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
pre: DetailedHTMLProps<HTMLAttributes<HTMLPreElement>, HTMLPreElement>;
progress: DetailedHTMLProps<ProgressHTMLAttributes<HTMLProgressElement>, HTMLProgressElement>;
q: DetailedHTMLProps<QuoteHTMLAttributes<HTMLQuoteElement>, HTMLQuoteElement>;
rp: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
rt: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
ruby: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
s: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
samp: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
search: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
slot: DetailedHTMLProps<SlotHTMLAttributes<HTMLSlotElement>, HTMLSlotElement>;
script: DetailedHTMLProps<ScriptHTMLAttributes<HTMLScriptElement>, HTMLScriptElement>;
section: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
select: DetailedHTMLProps<SelectHTMLAttributes<HTMLSelectElement>, HTMLSelectElement>;
small: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
source: DetailedHTMLProps<SourceHTMLAttributes<HTMLSourceElement>, HTMLSourceElement>;
span: DetailedHTMLProps<HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>;
strong: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
style: DetailedHTMLProps<StyleHTMLAttributes<HTMLStyleElement>, HTMLStyleElement>;
sub: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
summary: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
sup: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
table: DetailedHTMLProps<TableHTMLAttributes<HTMLTableElement>, HTMLTableElement>;
template: DetailedHTMLProps<HTMLAttributes<HTMLTemplateElement>, HTMLTemplateElement>;
tbody: DetailedHTMLProps<HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>;
td: DetailedHTMLProps<TdHTMLAttributes<HTMLTableDataCellElement>, HTMLTableDataCellElement>;
textarea: DetailedHTMLProps<TextareaHTMLAttributes<HTMLTextAreaElement>, HTMLTextAreaElement>;
tfoot: DetailedHTMLProps<HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>;
th: DetailedHTMLProps<ThHTMLAttributes<HTMLTableHeaderCellElement>, HTMLTableHeaderCellElement>;
thead: DetailedHTMLProps<HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>;
time: DetailedHTMLProps<TimeHTMLAttributes<HTMLTimeElement>, HTMLTimeElement>;
title: DetailedHTMLProps<HTMLAttributes<HTMLTitleElement>, HTMLTitleElement>;
tr: DetailedHTMLProps<HTMLAttributes<HTMLTableRowElement>, HTMLTableRowElement>;
track: DetailedHTMLProps<TrackHTMLAttributes<HTMLTrackElement>, HTMLTrackElement>;
u: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
ul: DetailedHTMLProps<HTMLAttributes<HTMLUListElement>, HTMLUListElement>;
"var": DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
video: DetailedHTMLProps<VideoHTMLAttributes<HTMLVideoElement>, HTMLVideoElement>;
wbr: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
webview: DetailedHTMLProps<WebViewHTMLAttributes<HTMLWebViewElement>, HTMLWebViewElement>;
svg: SVGProps<SVGSVGElement>;
animate: SVGProps<SVGElement>;
animateMotion: SVGProps<SVGElement>;
animateTransform: SVGProps<SVGElement>;
circle: SVGProps<SVGCircleElement>;
clipPath: SVGProps<SVGClipPathElement>;
defs: SVGProps<SVGDefsElement>;
desc: SVGProps<SVGDescElement>;
ellipse: SVGProps<SVGEllipseElement>;
feBlend: SVGProps<SVGFEBlendElement>;
feColorMatrix: SVGProps<SVGFEColorMatrixElement>;
feComponentTransfer: SVGProps<SVGFEComponentTransferElement>;
feComposite: SVGProps<SVGFECompositeElement>;
feConvolveMatrix: SVGProps<SVGFEConvolveMatrixElement>;
feDiffuseLighting: SVGProps<SVGFEDiffuseLightingElement>;
feDisplacementMap: SVGProps<SVGFEDisplacementMapElement>;
feDistantLight: SVGProps<SVGFEDistantLightElement>;
feDropShadow: SVGProps<SVGFEDropShadowElement>;
feFlood: SVGProps<SVGFEFloodElement>;
feFuncA: SVGProps<SVGFEFuncAElement>;
feFuncB: SVGProps<SVGFEFuncBElement>;
feFuncG: SVGProps<SVGFEFuncGElement>;
feFuncR: SVGProps<SVGFEFuncRElement>;
feGaussianBlur: SVGProps<SVGFEGaussianBlurElement>;
feImage: SVGProps<SVGFEImageElement>;
feMerge: SVGProps<SVGFEMergeElement>;
feMergeNode: SVGProps<SVGFEMergeNodeElement>;
feMorphology: SVGProps<SVGFEMorphologyElement>;
feOffset: SVGProps<SVGFEOffsetElement>;
fePointLight: SVGProps<SVGFEPointLightElement>;
feSpecularLighting: SVGProps<SVGFESpecularLightingElement>;
feSpotLight: SVGProps<SVGFESpotLightElement>;
feTile: SVGProps<SVGFETileElement>;
feTurbulence: SVGProps<SVGFETurbulenceElement>;
filter: SVGProps<SVGFilterElement>;
foreignObject: SVGProps<SVGForeignObjectElement>;
g: SVGProps<SVGGElement>;
image: SVGProps<SVGImageElement>;
line: SVGLineElementAttributes<SVGLineElement>;
linearGradient: SVGProps<SVGLinearGradientElement>;
marker: SVGProps<SVGMarkerElement>;
mask: SVGProps<SVGMaskElement>;
metadata: SVGProps<SVGMetadataElement>;
mpath: SVGProps<SVGElement>;
path: SVGProps<SVGPathElement>;
pattern: SVGProps<SVGPatternElement>;
polygon: SVGProps<SVGPolygonElement>;
polyline: SVGProps<SVGPolylineElement>;
radialGradient: SVGProps<SVGRadialGradientElement>;
rect: SVGProps<SVGRectElement>;
stop: SVGProps<SVGStopElement>;
switch: SVGProps<SVGSwitchElement>;
symbol: SVGProps<SVGSymbolElement>;
text: SVGTextElementAttributes<SVGTextElement>;
textPath: SVGProps<SVGTextPathElement>;
tspan: SVGProps<SVGTSpanElement>;
use: SVGProps<SVGUseElement>;
view: SVGProps<SVGViewElement>;
}
Referenced by
}
}

@types/react/canary

decl
module "@types/react/canary" {
}

@types/react/experimental

decl
module "@types/react/experimental" {
}

@types/react/jsx-runtime

decl
module "@types/react/jsx-runtime" {

JSX

decl
export namespace JSX {

ElementType

decl
export type ElementType = ElementType

Element

decl
export interface Element extends React.JSX.Element {}

ElementClass

decl
export interface ElementClass extends React.JSX.ElementClass {}

ElementAttributesProperty

decl
export interface ElementAttributesProperty extends React.JSX.ElementAttributesProperty {}

ElementChildrenAttribute

decl
export interface ElementChildrenAttribute extends React.JSX.ElementChildrenAttribute {}

LibraryManagedAttributes

decl
export type LibraryManagedAttributes<C, P> = LibraryManagedAttributes<C, P>

IntrinsicAttributes

decl
export interface IntrinsicAttributes extends React.JSX.IntrinsicAttributes {}

IntrinsicClassAttributes

decl
export interface IntrinsicClassAttributes<T> extends React.JSX.IntrinsicClassAttributes<T> {}

IntrinsicElements

decl
export interface IntrinsicElements extends React.JSX.IntrinsicElements {}
}
}

@types/react/jsx-dev-runtime

decl
module "@types/react/jsx-dev-runtime" {

JSX

decl
export namespace JSX {

ElementType

decl
export type ElementType = ElementType

Element

decl
export interface Element extends React.JSX.Element {}

ElementClass

decl
export interface ElementClass extends React.JSX.ElementClass {}

ElementAttributesProperty

decl
export interface ElementAttributesProperty extends React.JSX.ElementAttributesProperty {}

ElementChildrenAttribute

decl
export interface ElementChildrenAttribute extends React.JSX.ElementChildrenAttribute {}

LibraryManagedAttributes

decl
export type LibraryManagedAttributes<C, P> = LibraryManagedAttributes<C, P>

IntrinsicAttributes

decl
export interface IntrinsicAttributes extends React.JSX.IntrinsicAttributes {}

IntrinsicClassAttributes

decl
export interface IntrinsicClassAttributes<T> extends React.JSX.IntrinsicClassAttributes<T> {}

IntrinsicElements

decl
export interface IntrinsicElements extends React.JSX.IntrinsicElements {}
}
}