@types/react

Search for an npm package

@types/react

module "@types/react" {

@deprecated —

export function createFactory<T extends HTMLElement>(type: keyof ReactHTML): HTMLFactory<T>

@deprecated —

export function createFactory(type: keyof ReactSVG): SVGFactory

@deprecated —

export function createFactory<P extends DOMAttributes<T>, T extends Element>(type: string): DOMFactory<P, T>

@deprecated —

export function createFactory<P>(type: FunctionComponent<P>): FunctionComponentFactory<P>

@deprecated —

export function createFactory<P, T extends Component<P, ComponentState>, C extends ComponentClass<P>>(type: ClassType<P, T, C>): CFactory<P, T>

@deprecated —

export function createFactory<P>(type: ComponentClass<P>): Factory<P>
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 {}, 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>
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>

Lets you create a Context that components can provide or read.

more
less

@param — The value you want the context to have when there is no matching Provider in the tree above the component reading the context. This is meant as a "last resort" fallback.

@see — ://react.dev/reference/react/createContext#reference React Docs

@see — ://react-typescript-cheatsheet.netlify.app/docs/basic/getting-started/context/ React TypeScript Cheatsheet

@example — ```tsx import { createContext } from 'react';

const ThemeContext = createContext('light');

export function createContext<T>(defaultValue: T): Context<T>
export function isValidElement<P>(object: {} | null | undefined): object is ReactElement<P>
export function createRef<T>(): RefObject<T>

Lets your component expose a DOM node to a parent component using a ref.

more
less

@see — ://react.dev/reference/react/forwardRef React Docs

@see — ://react-typescript-cheatsheet.netlify.app/docs/basic/getting-started/forward_and_create_ref/ React TypeScript Cheatsheet

@param — See the ForwardRefRenderFunction.

@template — The type of the DOM node.

@template — The props the component accepts, if any.

@example — ```tsx interface Props { children?: ReactNode; type: "submit" | "button"; }

export const FancyButton = forwardRef<HTMLButtonElement, Props>((props, ref) => ( {props.children} ));

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

Lets you skip re-rendering a component when its props are unchanged.

more
less

@see — ://react.dev/reference/react/memo React Docs

@param — The component to memoize.

@param — A function that will be used to determine if the props have changed.

@example — ```tsx import { memo } from 'react';

const SomeComponent = memo(function SomeComponent(props: { foo: string }) { // ... });

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>

Lets you defer loading a component’s code until it is rendered for the first time.

more
less

@see — ://react.dev/reference/react/lazy React Docs

@param — A function that returns a Promise or another thenable (a Promise-like object with a then method). React will not call load until the first time you attempt to render the returned component. After React first calls load, it will wait for it to resolve, and then render the resolved value’s .default as a React component. Both the returned Promise and the Promise’s resolved value will be cached, so React will not call load more than once. If the Promise rejects, React will throw the rejection reason for the nearest Error Boundary to handle.

@example — ```tsx import { lazy } from 'react';

const MarkdownPreview = lazy(() => import('./MarkdownPreview.js'));

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

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

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>>]

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 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>

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

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 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 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 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): T

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

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

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]

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

Wrap any code rendering and triggering updates to your components into act() calls.

more
less

Ensures that the behavior in your tests matches what happens in the browser more closely by executing pending useEffects before returning. This also reduces the amount of re-renders done.

@param — A synchronous, void callback that will execute as a single, complete React commit.

@see — ://reactjs.org/blog/2019/02/06/react-v16.8.0.html#testing-hooks

export function act(callback: () => VoidOrUndefinedOnly): void
export function act<T>(callback: () => T | Promise<T>): Promise<T>
Unexported symbols referenced here
type VoidOrUndefinedOnly = void | {
[UNDEFINED_VOID_ONLY]: never;
}
Referenced by
export function useId(): string

@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

@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

Used to retrieve the possible components which accept a given set of props.

more
less

Can be passed no type parameters to get a union of all possible components and tags.

Is a superset of ComponentType.

@template — The props to match against. If not passed, defaults to any.

@template — An optional tag to match against. If not passed, attempts to match against all possible tags.

@example — ```tsx // All components and tags (img, embed etc.) // which accept src type SrcComponents = ElementType<{ src: any }>;

@example — ```tsx
// All components
type AllComponents = ElementType;

@example — ```tsx // All custom components which match src, and tags which // match src, narrowed down to just audio and embed type SrcComponents = ElementType<{ src: any }, 'audio' | 'embed'>;

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

Represents any user-defined component, either as a function or a class.

more
less

Similar to JSXElementConstructor, but with extra properties like defaultProps and contextTypes.

@template — The props the component accepts.

@see — ComponentClass

@see — FunctionComponent

export type ComponentType<P = {}> = ComponentClass<P> | FunctionComponent<P>
Referenced by

Represents any user-defined component, either as a function or a class.

more
less

Similar to ComponentType, but without extra properties like defaultProps and contextTypes.

@template — The props the component accepts.

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

A readonly ref container where current cannot be mutated.

more
less

Created by createRef, or useRef when passed null.

@template — The type of the ref's value.

@example — ```tsx const ref = createRef();

ref.current = document.createElement('div'); // Error

export interface RefObject<T> {

The current value of the ref.

readonly current: T | null;
}
Referenced by
export interface DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES {}
Referenced by

A callback fired whenever the ref's value changes.

more
less

@template — The type of the ref's value.

@see — ://react.dev/reference/react-dom/components/common#ref-callback React Docs

@example — ```tsx

export type RefCallback<T> = { }["bivarianceHack"]
Referenced by

A union type of all possible shapes for React refs.

more
less

@see — RefCallback

@see — RefObject

export type Ref<T> = RefCallback<T> | RefObject<T> | null
Referenced by

A legacy implementation of refs where you can pass a string to a ref prop.

more
less

@see — ://react.dev/reference/react/Component#refs React Docs

@example — ```tsx

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

Retrieves the type of the 'ref' prop for a given component type or tag name.

more
less

@template — The component type.

@example — ```tsx type MyComponentRef = React.ElementRef;

@example — ```tsx
type DivRef = React.ElementRef<'div'>;
export type ElementRef<C extends ForwardRefExoticComponent<any> | {
new (props: any): Component<any>;
} | ((props: any, deprecatedLegacyContext?: any) => ReactNode) | keyof IntrinsicElements> = "ref" extends keyof ComponentPropsWithRef<C> ? NonNullable<ComponentPropsWithRef<C>["ref"]> extends RefAttributes<infer Instance>["ref"] ? Instance : never : never

A value which uniquely identifies a node among items in an array.

more
less

@see — ://react.dev/learn/rendering-lists#keeping-list-items-in-order-with-key React Docs

export type Key = string | number | bigint
Referenced by

@internal — The props any component can receive. You don't have to add this type. All components automatically accept these props.

more
less
const Component = () => <div />;
<Component key="one" />

WARNING: The implementation of a component will never have access to these attributes. The following example would be incorrect usage because Component would never have access to key:

const Component = (props: React.Attributes) => props.key;
export interface Attributes {
key?: Key | null | undefined;
}
Referenced by

The props any component accepting refs can receive. Class components, built-in browser components (e.g. div) and forwardRef components can receive refs and automatically accept these props.

more
less
const Component = forwardRef(() => <div />);
<Component ref={(current) => console.log(current)} />

You only need this type if you manually author the types of props that need to be compatible with legacy refs.

interface Props extends React.RefAttributes<HTMLDivElement> {}
declare const Component: React.FunctionComponent<Props>;

Otherwise it's simpler to directly use Ref since you can safely use the props type to describe to props that a consumer can pass to the component as well as describing the props the implementation of a component "sees". RefAttributes is generally not safe to describe both consumer and seen props.

interface Props extends {
ref?: React.Ref<HTMLDivElement> | undefined;
}
declare const Component: React.FunctionComponent<Props>;

WARNING: The implementation of a component will not have access to the same type in versions of React supporting string refs. The following example would be incorrect usage because Component would never have access to a ref with type string

const Component = (props: React.RefAttributes) => props.ref;
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 React Docs

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

Represents the built-in attributes available to class components.

export interface ClassAttributes<T> extends RefAttributes<T> {}
Referenced by

Represents a JSX element.

more
less

Where ReactNode represents everything that can be rendered, ReactElement only represents JSX.

@template — The type of the props object

@template — The type of the component or tag

@example — ```tsx const element: ReactElement = ;

export interface ReactElement<P = any, T extends string | JSXElementConstructor<any> = string | JSXElementConstructor<any>> {
type: T;
props: P;
key: string | null;
}
Referenced by

@deprecated —

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

@deprecated — Use ComponentElement instead.

export type ClassicElement<P> = CElement<P, ClassicComponent<P, ComponentState>>
export interface DOMElement<P extends HTMLAttributes<T> | SVGAttributes<T>, T extends Element> extends ReactElement<P, string> {
ref: LegacyRef<T>;
}
Referenced by
export interface ReactHTMLElement<T extends HTMLElement> extends DetailedReactHTMLElement<AllHTMLAttributes<T>, T> {}
Referenced by
export interface DetailedReactHTMLElement<P extends HTMLAttributes<T>, T extends HTMLElement> extends DOMElement<P, T> {
type: keyof ReactHTML;
}
Referenced by
export interface ReactSVGElement extends DOMElement<SVGAttributes<SVGElement>, SVGElement> {
type: keyof ReactSVG;
}
Referenced by
export interface ReactPortal extends ReactElement {
children: ReactNode;
}
Referenced by
export type Factory<P> = (props?: Attributes & P, ...children: ReactNode[]) => ReactElement<P>
Referenced by

@deprecated — Please use FunctionComponentFactory

export type SFCFactory<P> = FunctionComponentFactory<P>
export type FunctionComponentFactory<P> = (props?: Attributes & P, ...children: ReactNode[]) => FunctionComponentElement<P>
Referenced by
export type ComponentFactory<P, T extends Component<P, ComponentState>> = (props?: ClassAttributes<T> & P, ...children: ReactNode[]) => CElement<P, T>
Referenced by
export type CFactory<P, T extends Component<P, ComponentState>> = ComponentFactory<P, T>
Referenced by
export type ClassicFactory<P> = CFactory<P, ClassicComponent<P, ComponentState>>
export type DOMFactory<P extends DOMAttributes<T>, T extends Element> = (props?: ClassAttributes<T> & P | null, ...children: ReactNode[]) => DOMElement<P, T>
Referenced by
export interface HTMLFactory<T extends HTMLElement> extends DetailedHTMLFactory<AllHTMLAttributes<T>, T> {}
Referenced by
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
export interface SVGFactory extends DOMFactory<SVGAttributes<SVGElement>, SVGElement> {
(props?: ClassAttributes<SVGElement> & SVGAttributes<SVGElement> | null, ...children: ReactNode[]): ReactSVGElement;
}
Referenced by

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

export type ReactText = string | number

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

export type ReactChild = ReactElement | string | number

@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[] {}

WARNING: Not related to React.Fragment.

more
less

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

export type ReactFragment = Iterable<ReactNode>

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

Represents all of the things React can render.

more
less

Where ReactElement only represents JSX, ReactNode represents everything that can be rendered.

@see — ://react-typescript-cheatsheet.netlify.app/docs/react-types/reactnode/ React TypeScript Cheatsheet

@example — ```tsx // Typing children type Props = { children: ReactNode }

const Component = ({ children }: Props) => {children}

hello

@example — ```tsx
// Typing a custom element
type Props = { customElement: ReactNode }
const Component = ({ customElement }: Props) => <div>{customElement}</div>
<Component customElement={<div>hello</div>} />
export type ReactNode = ReactElement | string | number | Iterable<ReactNode> | ReactPortal | boolean | null | undefined | DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_REACT_NODES[keyof DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_REACT_NODES]
Referenced by

Describes the props accepted by a Context Provider.

more
less

@template — The type of the value the context provides.

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

Describes the props accepted by a Context Consumer.

more
less

@template — The type of the value the context provides.

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

An object masquerading as a component. These are created by functions like forwardRef, memo, and createContext.

more
less

In order to make TypeScript work, we pretend that they are normal components.

But they are, in fact, not callable - instead, they are objects which are treated specially by the renderer.

@template — The props the component accepts.

export interface ExoticComponent<P = {}> {
(props: P): ReactNode;
readonly $$typeof: symbol;
}
Referenced by

An ExoticComponent with a displayName property applied to it.

more
less

@template — The props the component accepts.

export interface NamedExoticComponent<P = {}> extends ExoticComponent<P> {

Used in debugging messages. You might want to set it explicitly if you want to display a different name for debugging purposes.

more
less

@see — ://legacy.reactjs.org/docs/react-component.html#displayname Legacy React Docs

displayName?: string | undefined;
}
Referenced by

An ExoticComponent with a propTypes property applied to it.

more
less

@template — The props the component accepts.

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

Used to retrieve the type of a context object from a Context.

more
less

@template — The context object.

@example — ```tsx import { createContext } from 'react';

const MyContext = createContext({ foo: 'bar' });

type ContextType = ContextType; // ContextType = { foo: string }

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

Wraps your components to specify the value of this context for all components inside.

more
less

@see — ://react.dev/reference/react/createContext#provider React Docs

@example — ```tsx import { createContext } from 'react';

const ThemeContext = createContext('light');

function App() { return ( <ThemeContext.Provider value="dark"> </ThemeContext.Provider> ); }

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

The old way to read context, before useContext existed.

more
less

@see — ://react.dev/reference/react/createContext#consumer React Docs

@example — ```tsx import { UserContext } from './user-context';

function Avatar() { return ( <UserContext.Consumer> {user => } </UserContext.Consumer> ); }

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

Context lets components pass information deep down without explicitly passing props.

more
less

Created from createContext

@see — ://react.dev/learn/passing-data-deeply-with-context React Docs

@see — ://react-typescript-cheatsheet.netlify.app/docs/basic/getting-started/context/ React TypeScript Cheatsheet

@example — ```tsx import { createContext } from 'react';

const ThemeContext = createContext('light');

export interface Context<T> {
Provider: Provider<T>;
Consumer: Consumer<T>;

Used in debugging messages. You might want to set it explicitly if you want to display a different name for debugging purposes.

more
less

@see — ://legacy.reactjs.org/docs/react-component.html#displayname Legacy React Docs

displayName?: string | undefined;
}
Referenced by

Maintainer's note: Sync with ReactChildren until ReactChildren is removed.

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>[];
} = ...

Lets you group elements without a wrapper node.

more
less

@see — ://react.dev/reference/react/Fragment React Docs

@example — ```tsx import { Fragment } from 'react';

@example — ```tsx // Using the <></> shorthand syntax:

<>

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

Lets you find common bugs in your components early during development.

more
less

@see — ://react.dev/reference/react/StrictMode React Docs

@example — ```tsx import { StrictMode } from 'react';

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

The props accepted by Suspense.

more
less

@see — ://react.dev/reference/react/Suspense React Docs

export interface SuspenseProps {
children?: ReactNode | undefined;

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

fallback?: ReactNode;

A name for this Suspense boundary for instrumentation purposes. The name will help identify this boundary in React DevTools.

name?: string | undefined;
}
Referenced by

Lets you display a fallback until its children have finished loading.

more
less

@see — ://react.dev/reference/react/Suspense React Docs

@example — ```tsx import { Suspense } from 'react';

<Suspense fallback={}>

export const Suspense: ExoticComponent<SuspenseProps> = ...
export const version: string = ...

The callback passed to onRender.

more
less

@see — ://react.dev/reference/react/Profiler#onrender-callback React Docs

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

The props accepted by Profiler.

more
less

@see — ://react.dev/reference/react/Profiler React Docs

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

Lets you measure rendering performance of a React tree programmatically.

more
less

@see — ://react.dev/reference/react/Profiler#onrender-callback React Docs

@example — ```tsx

export const Profiler: ExoticComponent<ProfilerProps> = ...
export type ReactInstance = Component<any> | Element
Referenced by
export interface Component<P = {}, S = {}, SS = any> extends ComponentLifecycle<P, S, SS> {}
export class Component<P, S> {
constructor(props: P)

@deprecated —

more
less

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

constructor(props: P, context: any)

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

more
less

@example — ```ts type MyContext = number const Ctx = React.createContext(0)

class Foo extends React.Component { static contextType = Ctx context!: React.ContextType 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

@example — ```ts static contextType = MyContext // For TS pre-3.7: context!: React.ContextType // For TS 3.7 and above: declare context: React.ContextType

@see — ://react.dev/reference/react/Component#context React Docs
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 —

more
less

@see — ://legacy.reactjs.org/docs/refs-and-the-dom.html#legacy-api-string-refs Legacy React Docs

refs: {
[key: string]: ReactInstance;
};
}
Referenced by
export class PureComponent<P = {}, S = {}, SS = any> extends Component<P, S, SS> {}

@deprecated — Use ClassicComponent from create-react-class

more
less

@see — ://legacy.reactjs.org/docs/react-without-es6.html Legacy React Docs

@see — ://www.npmjs.com/package/create-react-class create-react-class on npm

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

Represents the type of a function component. Can optionally receive a type argument that represents the props the component receives.

more
less

@template — The props the component accepts.

@see — ://react-typescript-cheatsheet.netlify.app/docs/basic/getting-started/function_components React TypeScript Cheatsheet

@alias — for FunctionComponent

@example — ```tsx // With props: type Props = { name: string }

const MyComponent: FC = (props) => { return {props.name} }

@example — ```tsx
// Without props:
const MyComponentWithoutProps: FC = () => {
return <div>MyComponentWithoutProps</div>
}
export type FC<P = {}> = FunctionComponent<P>

Represents the type of a function component. Can optionally receive a type argument that represents the props the component accepts.

more
less

@template — The props the component accepts.

@see — ://react-typescript-cheatsheet.netlify.app/docs/basic/getting-started/function_components React TypeScript Cheatsheet

@example — ```tsx // With props: type Props = { name: string }

const MyComponent: FunctionComponent = (props) => { return {props.name} }

@example — ```tsx
// Without props:
const MyComponentWithoutProps: FunctionComponent = () => {
return <div>MyComponentWithoutProps</div>
}
export interface FunctionComponent<P = {}> {
(props: P, deprecatedLegacyContext?: any): ReactNode;

Used to declare the types of the props accepted by the component. These types will be checked during rendering and in development only.

more
less

We recommend using TypeScript instead of checking prop types at runtime.

@see — ://react.dev/reference/react/Component#static-proptypes React Docs

propTypes?: WeakValidationMap<P> | undefined;

@deprecated — Lets you specify which legacy context is consumed by this component.

more
less

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

contextTypes?: ValidationMap<any> | undefined;

Used to define default values for the props accepted by the component.

more
less

@see — ://react.dev/reference/react/Component#static-defaultprops React Docs

@example — ```tsx type Props = { name?: string }

const MyComponent: FC = (props) => { return {props.name} }

MyComponent.defaultProps = { name: 'John Doe' }

@deprecated — Use ://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment#default_value|default values for destructuring assignments instead.
defaultProps?: Partial<P> | undefined;

Used in debugging messages. You might want to set it explicitly if you want to display a different name for debugging purposes.

more
less

@see — ://legacy.reactjs.org/docs/react-component.html#displayname Legacy React Docs

@example — ```tsx

const MyComponent: FC = () => { return Hello! }

MyComponent.displayName = 'MyAwesomeComponent'

displayName?: string | undefined;
}
Referenced by

@deprecated — - Equivalent to FunctionComponent.

more
less

@see — FunctionComponent

@alias — VoidFunctionComponent

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

@deprecated — - Equivalent to FunctionComponent.

more
less

@see — FunctionComponent

export interface VoidFunctionComponent<P = {}> {
(props: P, deprecatedLegacyContext?: any): ReactNode;
propTypes?: WeakValidationMap<P> | undefined;
contextTypes?: ValidationMap<any> | undefined;

@deprecated — Use ://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment#default_value|default values for destructuring assignments instead.

defaultProps?: Partial<P> | undefined;
displayName?: string | undefined;
}
Referenced by

The type of the ref received by a ForwardRefRenderFunction.

more
less

@see — ForwardRefRenderFunction

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

The type of the function passed to forwardRef. This is considered different to a normal FunctionComponent because it receives an additional argument,

more
less

@param — Props passed to the component, if any.

@param — A ref forwarded to the component of type ForwardedRef.

@template — The type of the forwarded ref.

@template — The type of the props the component accepts.

@see — ://react-typescript-cheatsheet.netlify.app/docs/basic/getting-started/forward_and_create_ref/ React TypeScript Cheatsheet

@see — forwardRef

export interface ForwardRefRenderFunction<T, P = {}> {
(props: P, ref: ForwardedRef<T>): ReactNode;

Used in debugging messages. You might want to set it explicitly if you want to display a different name for debugging purposes.

more
less

Will show ForwardRef(${Component.displayName || Component.name}) in devtools by default, but can be given its own specific name.

@see — ://legacy.reactjs.org/docs/react-component.html#displayname Legacy React Docs

displayName?: string | undefined;

defaultProps are not supported on render functions passed to forwardRef.

more
less

@see — ://github.com/microsoft/TypeScript/issues/36826 linked GitHub issue for context

@see — ://react.dev/reference/react/Component#static-defaultprops React Docs

defaultProps?: never | undefined;

propTypes are not supported on render functions passed to forwardRef.

more
less

@see — ://github.com/microsoft/TypeScript/issues/36826 linked GitHub issue for context

@see — ://react.dev/reference/react/Component#static-proptypes React Docs

propTypes?: never | undefined;
}
Referenced by

Represents a component class in React.

more
less

@template — The props the component accepts.

@template — The internal state of the component.

export interface ComponentClass<P = {}, S = ComponentState> extends StaticLifecycle<P, S> {
new (props: P, deprecatedLegacyContext?: any): Component<P, S>;

Used to declare the types of the props accepted by the component. These types will be checked during rendering and in development only.

more
less

We recommend using TypeScript instead of checking prop types at runtime.

@see — ://react.dev/reference/react/Component#static-proptypes React Docs

propTypes?: WeakValidationMap<P> | undefined;
contextType?: Context<any> | undefined;

@deprecated — use contextType instead

more
less

Lets you specify which legacy context is consumed by this component.

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

contextTypes?: ValidationMap<any> | undefined;

@deprecated —

more
less

@see — ://legacy.reactjs.org/docs/legacy-context.html#how-to-use-context Legacy React Docs

childContextTypes?: ValidationMap<any> | undefined;

Used to define default values for the props accepted by the component.

more
less

@see — ://react.dev/reference/react/Component#static-defaultprops React Docs

defaultProps?: Partial<P> | undefined;

Used in debugging messages. You might want to set it explicitly if you want to display a different name for debugging purposes.

more
less

@see — ://legacy.reactjs.org/docs/react-component.html#displayname Legacy React Docs

displayName?: string | undefined;
}
Referenced by

@deprecated — Use ClassicComponentClass from create-react-class

more
less

@see — ://legacy.reactjs.org/docs/react-without-es6.html Legacy React Docs

@see — ://www.npmjs.com/package/create-react-class create-react-class on npm

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

Used in createElement and createFactory to represent a class.

more
less

An intersection type is used to infer multiple type parameters from a single argument, which is useful for many top-level API defs. See ://github.com/Microsoft/TypeScript/issues/7234 this GitHub issue for more info.

export type ClassType<P, T extends Component<P, ComponentState>, C extends ComponentClass<P>> = C & (new (props: P, deprecatedLegacyContext?: any) => T)
Referenced by
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, 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
export interface StaticLifecycle<P, S> {
getDerivedStateFromProps?: GetDerivedStateFromProps<P, S> | undefined;
getDerivedStateFromError?: GetDerivedStateFromError<P, S> | undefined;
}
Referenced by
export type GetDerivedStateFromProps<P, S> = (nextProps: Readonly<P>, prevState: S) => Partial<S> | null
Referenced by
export type GetDerivedStateFromError<P, S> = (error: any) => Partial<S> | null
Referenced by
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 this method 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
export interface DeprecatedLifecycle<P, S> {

Called immediately before mounting occurs, and before 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 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 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 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 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 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

@deprecated —

more
less

@see — ://legacy.reactjs.org/blog/2016/07/13/mixins-considered-harmful.html Mixins Considered Harmful

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

@deprecated —

more
less

@see — ://legacy.reactjs.org/blog/2016/07/13/mixins-considered-harmful.html Mixins Considered Harmful

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

The type of the component returned from forwardRef.

more
less

@template — The props the component accepts, if any.

@see — ExoticComponent

export interface ForwardRefExoticComponent<P> extends NamedExoticComponent<P> {

@deprecated — Use ://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment#default_value|default values for destructuring assignments instead.

defaultProps?: Partial<P> | undefined;
propTypes?: WeakValidationMap<P> | undefined;
}
Referenced by

Omits the 'ref' attribute from the given props object.

more
less

@template — The props object type.

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

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
export type PropsWithChildren<P = unknown> = P & {
children?: ReactNode | undefined;
}

Used to retrieve the props a component accepts. Can either be passed a string, indicating a DOM element (e.g. 'div', 'span', etc.) or the type of a React component.

more
less

It's usually better to use ComponentPropsWithRef or ComponentPropsWithoutRef instead of this type, as they let you be explicit about whether or not to include the ref prop.

@see — ://react-typescript-cheatsheet.netlify.app/docs/react-types/componentprops/ React TypeScript Cheatsheet

@example — ```tsx // Retrieves the props an 'input' element accepts type InputProps = React.ComponentProps<'input'>;

@example — ```tsx
const MyComponent = (props: { foo: number, bar: string }) => <div />;
// Retrieves the props 'MyComponent' accepts
type MyComponentProps = React.ComponentProps<typeof MyComponent>;
export type ComponentProps<T extends keyof IntrinsicElements | JSXElementConstructor<any>> = T extends JSXElementConstructor<infer P> ? P : T extends keyof IntrinsicElements ? IntrinsicElements[T] : {}
Referenced by

Used to retrieve the props a component accepts with its ref. Can either be passed a string, indicating a DOM element (e.g. 'div', 'span', etc.) or the type of a React component.

more
less

@see — ://react-typescript-cheatsheet.netlify.app/docs/react-types/componentprops/ React TypeScript Cheatsheet

@example — ```tsx // Retrieves the props an 'input' element accepts type InputProps = React.ComponentPropsWithRef<'input'>;

@example — ```tsx
const MyComponent = (props: { foo: number, bar: string }) => <div />;
// Retrieves the props 'MyComponent' accepts
type MyComponentPropsWithRef = React.ComponentPropsWithRef<typeof MyComponent>;
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

Used to retrieve the props a custom component accepts with its ref.

more
less

Unlike ComponentPropsWithRef, this only works with custom components, i.e. components you define yourself. This is to improve type-checking performance.

@example — ```tsx const MyComponent = (props: { foo: number, bar: string }) => ;

// Retrieves the props 'MyComponent' accepts type MyComponentPropsWithRef = React.CustomComponentPropsWithRef;

export type CustomComponentPropsWithRef<T extends ComponentType> = T extends (new (props: infer P) => Component<any, any>) ? (PropsWithoutRef<P> & RefAttributes<InstanceType<T>>) : T extends ((props: infer P, legacyContext?: any) => ReactNode) ? PropsWithRef<P> : never
Referenced by

Used to retrieve the props a component accepts without its ref. Can either be passed a string, indicating a DOM element (e.g. 'div', 'span', etc.) or the type of a React component.

more
less

@see — ://react-typescript-cheatsheet.netlify.app/docs/react-types/componentprops/ React TypeScript Cheatsheet

@example — ```tsx // Retrieves the props an 'input' element accepts type InputProps = React.ComponentPropsWithoutRef<'input'>;

@example — ```tsx
const MyComponent = (props: { foo: number, bar: string }) => <div />;
// Retrieves the props 'MyComponent' accepts
type MyComponentPropsWithoutRef = React.ComponentPropsWithoutRef<typeof MyComponent>;
export type ComponentPropsWithoutRef<T extends ElementType> = PropsWithoutRef<ComponentProps<T>>
Referenced by
export type ComponentRef<T extends ElementType> = T extends NamedExoticComponent<ComponentPropsWithoutRef<T> & RefAttributes<infer Method>> ? Method : ComponentPropsWithRef<T> extends RefAttributes<infer Method> ? Method : never
export type MemoExoticComponent<T extends ComponentType<any>> = NamedExoticComponent<CustomComponentPropsWithRef<T>> & {
readonly type: T;
}
Referenced by
export interface LazyExoticComponent<T extends ComponentType<any>> extends ExoticComponent<CustomComponentPropsWithRef<T>> {
readonly _result: T;
}
Referenced by

The instruction passed to a Dispatch function in useState to tell React what the next value of the useState should be.

more
less

Often found wrapped in Dispatch.

@template — The type of the state.

@example — ```tsx // This return type correctly represents the type of // setCount in the example below. const useCustomState = (): Dispatch<SetStateAction> => { const [count, setCount] = useState(0);

return setCount; }

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

A function that can be used to update the state of a useState or useReducer hook.

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

A Dispatch function can sometimes be called without any arguments.

export type DispatchWithoutAction = () => void
Referenced by
export type Reducer<S, A> = (prevState: S, action: A) => S
Referenced by
export type ReducerWithoutAction<S> = (prevState: S) => S
Referenced by
export type ReducerState<R extends Reducer<any, any>> = R extends Reducer<infer S, any> ? S : never
Referenced by
export type ReducerAction<R extends Reducer<any, any>> = R extends Reducer<any, infer A> ? A : never
Referenced by
export type ReducerStateWithoutAction<R extends ReducerWithoutAction<any>> = R extends ReducerWithoutAction<infer S> ? S : never
Referenced by
export type EffectCallback = () => void | Destructor
Referenced by
Unexported symbols referenced here

The function returned from an effect passed to useEffect, which can be used to clean up the effect when the component unmounts.

more
less

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

type Destructor = () => void | {
[UNDEFINED_VOID_ONLY]: never;
}
Referenced by
export interface MutableRefObject<T> {
current: T;
}
Referenced by
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
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

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
export interface ClipboardEvent<T = Element> extends SyntheticEvent<T, NativeClipboardEvent> {
clipboardData: DataTransfer;
}
Referenced by
Unexported symbols referenced here
type NativeClipboardEvent = ClipboardEvent
Referenced by
export interface CompositionEvent<T = Element> extends SyntheticEvent<T, NativeCompositionEvent> {
data: string;
}
Referenced by
Unexported symbols referenced here
type NativeCompositionEvent = CompositionEvent
Referenced by
export interface DragEvent<T = Element> extends MouseEvent<T, NativeDragEvent> {
dataTransfer: DataTransfer;
}
Referenced by
Unexported symbols referenced here
type NativeDragEvent = DragEvent
Referenced by
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
type NativePointerEvent = PointerEvent
Referenced by
export interface FocusEvent<Target = Element, RelatedTarget = Element> extends SyntheticEvent<Target, NativeFocusEvent> {
relatedTarget: (EventTarget & RelatedTarget) | null;
target: EventTarget & Target;
}
Referenced by
Unexported symbols referenced here
type NativeFocusEvent = FocusEvent
Referenced by
export interface FormEvent<T = Element> extends SyntheticEvent<T> {}
Referenced by
export interface InvalidEvent<T = Element> extends SyntheticEvent<T> {
target: EventTarget & T;
}
export interface ChangeEvent<T = Element> extends SyntheticEvent<T> {
target: EventTarget & T;
}
Referenced by
export type ModifierKey = "Alt" | "AltGraph" | "CapsLock" | "Control" | "Fn" | "FnLock" | "Hyper" | "Meta" | "NumLock" | "ScrollLock" | "Shift" | "Super" | "Symbol" | "SymbolLock"
Referenced by
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
type NativeKeyboardEvent = KeyboardEvent
Referenced by
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
type NativeMouseEvent = MouseEvent
Referenced by
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
type NativeTouchEvent = TouchEvent
Referenced by
export interface UIEvent<T = Element, E = NativeUIEvent> extends SyntheticEvent<T, E> {
detail: number;
}
Referenced by
Unexported symbols referenced here
type NativeUIEvent = UIEvent
Referenced by
export interface WheelEvent<T = Element> extends MouseEvent<T, NativeWheelEvent> {
deltaMode: number;
deltaX: number;
deltaY: number;
deltaZ: number;
}
Referenced by
Unexported symbols referenced here
type NativeWheelEvent = WheelEvent
Referenced by
export interface AnimationEvent<T = Element> extends SyntheticEvent<T, NativeAnimationEvent> {
animationName: string;
elapsedTime: number;
pseudoElement: string;
}
Referenced by
Unexported symbols referenced here
type NativeAnimationEvent = AnimationEvent
Referenced by
export interface TransitionEvent<T = Element> extends SyntheticEvent<T, NativeTransitionEvent> {
elapsedTime: number;
propertyName: string;
pseudoElement: string;
}
Referenced by
Unexported symbols referenced here
type NativeTransitionEvent = TransitionEvent
Referenced by
export type ClipboardEventHandler<T = Element> = EventHandler<ClipboardEvent<T>>
Referenced by
export type CompositionEventHandler<T = Element> = EventHandler<CompositionEvent<T>>
Referenced by
export type DragEventHandler<T = Element> = EventHandler<DragEvent<T>>
Referenced by
export type FocusEventHandler<T = Element> = EventHandler<FocusEvent<T>>
Referenced by
export type FormEventHandler<T = Element> = EventHandler<FormEvent<T>>
Referenced by
export type KeyboardEventHandler<T = Element> = EventHandler<KeyboardEvent<T>>
Referenced by
export type MouseEventHandler<T = Element> = EventHandler<MouseEvent<T>>
Referenced by
export type TouchEventHandler<T = Element> = EventHandler<TouchEvent<T>>
Referenced by
export type PointerEventHandler<T = Element> = EventHandler<PointerEvent<T>>
Referenced by
export type UIEventHandler<T = Element> = EventHandler<UIEvent<T>>
Referenced by
export type WheelEventHandler<T = Element> = EventHandler<WheelEvent<T>>
Referenced by
export type AnimationEventHandler<T = Element> = EventHandler<AnimationEvent<T>>
Referenced by
export type TransitionEventHandler<T = Element> = EventHandler<TransitionEvent<T>>
Referenced by
export interface HTMLProps<T> extends AllHTMLAttributes<T>, ClassAttributes<T> {}
export type DetailedHTMLProps<E extends HTMLAttributes<T>, T> = ClassAttributes<T> & E
Referenced by
export interface SVGLineElementAttributes<T> extends SVGProps<T> {}
Referenced by
export interface SVGTextElementAttributes<T> extends SVGProps<T> {}
Referenced by
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 — Use onKeyUp or onKeyDown instead

onKeyPress?: KeyboardEventHandler<T> | undefined;

@deprecated — Use onKeyUpCapture or onKeyDownCapture instead

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;
onPointerLeave?: 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
interface TrustedHTML {}
Referenced by
export interface CSSProperties extends import("csstype").Properties<string | number> {}
Referenced by
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

Used to represent DOM API's where users can either pass true or false as a boolean or as its equivalent strings.

type Booleanish = boolean | "true" | "false"
Referenced by
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
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;
autoCapitalize?: "off" | "none" | "on" | "sentences" | "words" | "characters" | undefined | (string & {});
autoFocus?: boolean | undefined;
className?: string | undefined;
contentEditable?: Booleanish | "inherit" | "plaintext-only" | undefined;
contextMenu?: string | undefined;
dir?: string | undefined;
draggable?: Booleanish | undefined;
enterKeyHint?: "enter" | "done" | "go" | "next" | "previous" | "search" | "send" | undefined;
hidden?: boolean | undefined;
id?: string | undefined;
lang?: string | undefined;
nonce?: 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;
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

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
export interface AllHTMLAttributes<T> extends HTMLAttributes<T> {
accept?: string | undefined;
acceptCharset?: string | undefined;
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;
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

@see — ://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/crossorigin MDN

type CrossOrigin = "anonymous" | "use-credentials" | "" | undefined
Referenced by
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
export type HTMLAttributeAnchorTarget = "_self" | "_blank" | "_parent" | "_top" | (string & {})
Referenced by
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
export interface AudioHTMLAttributes<T> extends MediaHTMLAttributes<T> {}
Referenced by
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
export interface BaseHTMLAttributes<T> extends HTMLAttributes<T> {
href?: string | undefined;
target?: string | undefined;
}
Referenced by
export interface BlockquoteHTMLAttributes<T> extends HTMLAttributes<T> {
cite?: string | undefined;
}
Referenced by
export interface ButtonHTMLAttributes<T> extends HTMLAttributes<T> {
disabled?: boolean | undefined;
form?: string | 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
export interface CanvasHTMLAttributes<T> extends HTMLAttributes<T> {
height?: number | string | undefined;
width?: number | string | undefined;
}
Referenced by
export interface ColHTMLAttributes<T> extends HTMLAttributes<T> {
span?: number | undefined;
width?: number | string | undefined;
}
Referenced by
export interface ColgroupHTMLAttributes<T> extends HTMLAttributes<T> {
span?: number | undefined;
}
Referenced by
export interface DataHTMLAttributes<T> extends HTMLAttributes<T> {
value?: string | readonly string[] | number | undefined;
}
Referenced by
export interface DetailsHTMLAttributes<T> extends HTMLAttributes<T> {
open?: boolean | undefined;
onToggle?: ReactEventHandler<T> | undefined;
name?: string | undefined;
}
Referenced by
export interface DelHTMLAttributes<T> extends HTMLAttributes<T> {
cite?: string | undefined;
dateTime?: string | undefined;
}
Referenced by
export interface DialogHTMLAttributes<T> extends HTMLAttributes<T> {
onCancel?: ReactEventHandler<T> | undefined;
onClose?: ReactEventHandler<T> | undefined;
open?: boolean | undefined;
}
Referenced by
export interface EmbedHTMLAttributes<T> extends HTMLAttributes<T> {
height?: number | string | undefined;
src?: string | undefined;
type?: string | undefined;
width?: number | string | undefined;
}
Referenced by
export interface FieldsetHTMLAttributes<T> extends HTMLAttributes<T> {
disabled?: boolean | undefined;
form?: string | undefined;
name?: string | undefined;
}
Referenced by
export interface FormHTMLAttributes<T> extends HTMLAttributes<T> {
acceptCharset?: string | undefined;
autoComplete?: string | undefined;
encType?: string | undefined;
method?: string | undefined;
name?: string | undefined;
noValidate?: boolean | undefined;
target?: string | undefined;
}
Referenced by
export interface HtmlHTMLAttributes<T> extends HTMLAttributes<T> {
manifest?: string | undefined;
}
Referenced by
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
export interface ImgHTMLAttributes<T> extends HTMLAttributes<T> {
alt?: string | undefined;
crossOrigin?: CrossOrigin;
decoding?: "async" | "auto" | "sync" | undefined;
fetchPriority?: "high" | "low" | "auto";
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
export interface InsHTMLAttributes<T> extends HTMLAttributes<T> {
cite?: string | undefined;
dateTime?: string | undefined;
}
Referenced by
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
export type AutoFillAddressKind = "billing" | "shipping"
Referenced by
export type AutoFillBase = "" | "off" | "on"
Referenced by
export type AutoFillContactField = "email" | "tel" | "tel-area-code" | "tel-country-code" | "tel-extension" | "tel-local" | "tel-local-prefix" | "tel-local-suffix" | "tel-national"
Referenced by
export type AutoFillContactKind = "home" | "mobile" | "work"
Referenced by
export type AutoFillCredentialField = "webauthn"
Referenced by
export type AutoFillNormalField = "additional-name" | "address-level1" | "address-level2" | "address-level3" | "address-level4" | "address-line1" | "address-line2" | "address-line3" | "bday-day" | "bday-month" | "bday-year" | "cc-csc" | "cc-exp" | "cc-exp-month" | "cc-exp-year" | "cc-family-name" | "cc-given-name" | "cc-name" | "cc-number" | "cc-type" | "country" | "country-name" | "current-password" | "family-name" | "given-name" | "honorific-prefix" | "honorific-suffix" | "name" | "new-password" | "one-time-code" | "organization" | "postal-code" | "street-address" | "transaction-amount" | "transaction-currency" | "username"
Referenced by
export type OptionalPrefixToken<T extends string> = `${T} ` | ""
Referenced by
export type OptionalPostfixToken<T extends string> = ` ${T}` | ""
Referenced by
export type AutoFillSection = `section-${string}`
Referenced by
export type HTMLInputAutoCompleteAttribute = AutoFill | (string & {})
Referenced by
export interface InputHTMLAttributes<T> extends HTMLAttributes<T> {
accept?: string | undefined;
alt?: string | undefined;
autoComplete?: HTMLInputAutoCompleteAttribute | undefined;
capture?: boolean | "user" | "environment" | undefined;
checked?: boolean | undefined;
disabled?: boolean | undefined;
form?: string | 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
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
export interface LabelHTMLAttributes<T> extends HTMLAttributes<T> {
form?: string | undefined;
htmlFor?: string | undefined;
}
Referenced by
export interface LiHTMLAttributes<T> extends HTMLAttributes<T> {
value?: string | readonly string[] | number | undefined;
}
Referenced by
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
export interface MapHTMLAttributes<T> extends HTMLAttributes<T> {
name?: string | undefined;
}
Referenced by
export interface MenuHTMLAttributes<T> extends HTMLAttributes<T> {
type?: string | undefined;
}
Referenced by
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
export interface MetaHTMLAttributes<T> extends HTMLAttributes<T> {
charSet?: string | undefined;
content?: string | undefined;
httpEquiv?: string | undefined;
media?: string | undefined;
name?: string | undefined;
}
Referenced by
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
export interface QuoteHTMLAttributes<T> extends HTMLAttributes<T> {
cite?: string | undefined;
}
Referenced by
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
export interface OlHTMLAttributes<T> extends HTMLAttributes<T> {
reversed?: boolean | undefined;
start?: number | undefined;
type?: "1" | "a" | "A" | "i" | "I" | undefined;
}
Referenced by
export interface OptgroupHTMLAttributes<T> extends HTMLAttributes<T> {
disabled?: boolean | undefined;
label?: string | undefined;
}
Referenced by
export interface OptionHTMLAttributes<T> extends HTMLAttributes<T> {
disabled?: boolean | undefined;
label?: string | undefined;
selected?: boolean | undefined;
value?: string | readonly string[] | number | undefined;
}
Referenced by
export interface OutputHTMLAttributes<T> extends HTMLAttributes<T> {
form?: string | undefined;
htmlFor?: string | undefined;
name?: string | undefined;
}
Referenced by
export interface ParamHTMLAttributes<T> extends HTMLAttributes<T> {
name?: string | undefined;
value?: string | readonly string[] | number | undefined;
}
Referenced by
export interface ProgressHTMLAttributes<T> extends HTMLAttributes<T> {
max?: number | string | undefined;
value?: string | readonly string[] | number | undefined;
}
Referenced by
export interface SlotHTMLAttributes<T> extends HTMLAttributes<T> {
name?: string | undefined;
}
Referenced by
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
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
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
export interface StyleHTMLAttributes<T> extends HTMLAttributes<T> {
media?: string | undefined;
scoped?: boolean | undefined;
type?: string | undefined;
}
Referenced by
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
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
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
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
export interface TimeHTMLAttributes<T> extends HTMLAttributes<T> {
dateTime?: string | undefined;
}
Referenced by
export interface TrackHTMLAttributes<T> extends HTMLAttributes<T> {
default?: boolean | undefined;
kind?: string | undefined;
label?: string | undefined;
src?: string | undefined;
srcLang?: string | undefined;
}
Referenced by
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
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
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
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>;
}
Referenced by
Unexported symbols referenced here
interface HTMLWebViewElement extends HTMLElement {}
Referenced by
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;
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;
switch: SVGFactory;
symbol: SVGFactory;
text: SVGFactory;
textPath: SVGFactory;
tspan: SVGFactory;
view: SVGFactory;
}
Referenced by
export interface ReactDOM extends ReactHTML, ReactSVG {}

@deprecated — Use Validator from the ´prop-types` instead.

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

@deprecated — Use Requireable from the ´prop-types` instead.

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

@deprecated — Use ValidationMap from the ´prop-types` instead.

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

@deprecated — Use WeakValidationMap from the ´prop-types` instead.

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

@deprecated — Use PropTypes.* where PropTypes comes from import * as PropTypes from 'prop-types' instead.

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

@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>[];
}
export interface AbstractView {
styleMedia: StyleMedia;
document: Document;
}
Referenced by
export interface Touch {
identifier: number;
target: EventTarget;
screenX: number;
screenY: number;
clientX: number;
clientY: number;
pageX: number;
pageY: number;
}
Referenced by
export interface TouchList {
[key: number]: Touch;
length: number;
item(index: number): Touch;
identifiedTouch(identifier: number): Touch;
}
Referenced by
export interface ErrorInfo {

Captures which component contained the exception, and its ancestors.

componentStack?: string | null;
digest?: string | null;
}
Referenced by
export namespace JSX {
export type ElementType = GlobalJSXElementType
Unexported symbols referenced here
type GlobalJSXElementType = ElementType
Referenced by
type ElementType = string | JSXElementConstructor<any>
Referenced by
export interface Element extends GlobalJSXElement {}
Unexported symbols referenced here
interface GlobalJSXElement extends Element {}
Referenced by
interface Element extends ReactElement<any, any> {}
Referenced by
export interface ElementClass extends GlobalJSXElementClass {}
Unexported symbols referenced here
interface GlobalJSXElementClass extends ElementClass {}
Referenced by
interface ElementClass extends Component<any> {
render(): ReactNode;
}
Referenced by
export interface ElementAttributesProperty extends GlobalJSXElementAttributesProperty {}
Unexported symbols referenced here
interface GlobalJSXElementAttributesProperty extends ElementAttributesProperty {}
Referenced by
interface ElementAttributesProperty {
props: {};
}
Referenced by
export interface ElementChildrenAttribute extends GlobalJSXElementChildrenAttribute {}
Unexported symbols referenced here
interface GlobalJSXElementChildrenAttribute extends ElementChildrenAttribute {}
Referenced by
interface ElementChildrenAttribute {
children: {};
}
Referenced by
export type LibraryManagedAttributes<C, P> = GlobalJSXLibraryManagedAttributes<C, P>
Unexported symbols referenced here
type GlobalJSXLibraryManagedAttributes<C, P> = LibraryManagedAttributes<C, P>
Referenced by
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
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
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
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
type InexactPartial<T> = {
[K in keyof T]?: T[K] | undefined;
}
Referenced by
type IsExactlyAny<T> = boolean extends (T extends never ? true : false) ? true : false
Referenced by
type NotExactlyAnyPropertyKeys<T> = Exclude<keyof T, ExactlyAnyPropertyKeys<T>>
Referenced by
type ExactlyAnyPropertyKeys<T> = {
[K in keyof T]: IsExactlyAny<T[K]> extends true ? K : never;
}[keyof T]
Referenced by
export interface IntrinsicAttributes extends GlobalJSXIntrinsicAttributes {}
Unexported symbols referenced here
interface GlobalJSXIntrinsicAttributes extends IntrinsicAttributes {}
Referenced by
interface IntrinsicAttributes extends Attributes {}
Referenced by
export interface IntrinsicClassAttributes<T> extends GlobalJSXIntrinsicClassAttributes<T> {}
Unexported symbols referenced here
interface GlobalJSXIntrinsicClassAttributes<T> extends IntrinsicClassAttributes<T> {}
Referenced by
interface IntrinsicClassAttributes<T> extends ClassAttributes<T> {}
Referenced by
export interface IntrinsicElements extends GlobalJSXIntrinsicElements {}
Referenced by
Unexported symbols referenced here
interface GlobalJSXIntrinsicElements extends IntrinsicElements {}
Referenced by
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>;
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>;
set: SVGProps<SVGSetElement>;
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
}
}
module "@types/react/canary" {
}
module "@types/react/experimental" {
}
module "@types/react/jsx-runtime" {

Create a React element.

more
less

You should not use this function directly. Use JSX and a transpiler instead.

export function jsx(type: ElementType, props: unknown, key?: Key): ReactElement

Create a React element.

more
less

You should not use this function directly. Use JSX and a transpiler instead.

export function jsxs(type: ElementType, props: unknown, key?: Key): ReactElement
export {
Fragment,
} from "unknown"
export namespace JSX {
export type ElementType = ElementType
export interface Element extends React.JSX.Element {}
export interface ElementClass extends React.JSX.ElementClass {}
export interface ElementAttributesProperty extends React.JSX.ElementAttributesProperty {}
export interface ElementChildrenAttribute extends React.JSX.ElementChildrenAttribute {}
export type LibraryManagedAttributes<C, P> = LibraryManagedAttributes<C, P>
export interface IntrinsicAttributes extends React.JSX.IntrinsicAttributes {}
export interface IntrinsicClassAttributes<T> extends React.JSX.IntrinsicClassAttributes<T> {}
export interface IntrinsicElements extends React.JSX.IntrinsicElements {}
}
}
module "@types/react/jsx-dev-runtime" {

Create a React element.

more
less

You should not use this function directly. Use JSX and a transpiler instead.

export function jsxDEV(type: ElementType, props: unknown, key: Key | undefined, isStatic: boolean, source?: JSXSource, self?: unknown): ReactElement
export {
Fragment,
} from "unknown"
export namespace JSX {
export type ElementType = ElementType
export interface Element extends React.JSX.Element {}
export interface ElementClass extends React.JSX.ElementClass {}
export interface ElementAttributesProperty extends React.JSX.ElementAttributesProperty {}
export interface ElementChildrenAttribute extends React.JSX.ElementChildrenAttribute {}
export type LibraryManagedAttributes<C, P> = LibraryManagedAttributes<C, P>
export interface IntrinsicAttributes extends React.JSX.IntrinsicAttributes {}
export interface IntrinsicClassAttributes<T> extends React.JSX.IntrinsicClassAttributes<T> {}
export interface IntrinsicElements extends React.JSX.IntrinsicElements {}
}
export interface JSXSource {

The source file where the element originates from.

fileName?: string | undefined;

The line number where the element was created.

lineNumber?: number | undefined;

The column number where the element was created.

columnNumber?: number | undefined;
}
Referenced by
}