@types/react

  • Version 18.2.61
  • Published
  • 427 kB
  • 3 dependencies
  • MIT license

Install

npm i @types/react
yarn add @types/react
pnpm add @types/react

Overview

TypeScript definitions for react

Index

Variables

Functions

Classes

Interfaces

Type Aliases

Namespaces

Variables

variable Children

const Children: {
map<T, C>(
children: C | readonly C[],
fn: (child: C, index: number) => T
): C extends null ? C : Exclude<T, boolean>[];
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[]
): Array<Exclude<ReactNode, boolean | null | undefined>>;
};

variable Fragment

const Fragment: ExoticComponent<{ children?: ReactNode | undefined }>;
  • Lets you group elements without a wrapper node.

    Example 1

    import { Fragment } from 'react';
    <Fragment>
    <td>Hello</td>
    <td>World</td>
    </Fragment>

    Example 2

    // Using the <></> shorthand syntax:
    <>
    <td>Hello</td>
    <td>World</td>
    </>

    See Also

variable Profiler

const Profiler: ExoticComponent<ProfilerProps>;
  • Lets you measure rendering performance of a React tree programmatically.

    Example 1

    <Profiler id="App" onRender={onRender}>
    <App />
    </Profiler>

    See Also

variable StrictMode

const StrictMode: ExoticComponent<{ children?: ReactNode | undefined }>;
  • Lets you find common bugs in your components early during development.

    Example 1

    import { StrictMode } from 'react';
    <StrictMode>
    <App />
    </StrictMode>

    See Also

variable Suspense

const Suspense: ExoticComponent<SuspenseProps>;
  • Lets you display a fallback until its children have finished loading.

    Example 1

    import { Suspense } from 'react';
    <Suspense fallback={<Loading />}>
    <ProfileDetails />
    </Suspense>

    See Also

variable UNDEFINED_VOID_ONLY

const UNDEFINED_VOID_ONLY: Symbol;

    variable unstable_SuspenseList

    const unstable_SuspenseList: ExoticComponent<SuspenseListProps>;
    • SuspenseList helps coordinate many components that can suspend by orchestrating the order in which these components are revealed to the user.

      When multiple components need to fetch data, this data may arrive in an unpredictable order. However, if you wrap these items in a SuspenseList, React will not show an item in the list until previous items have been displayed (this behavior is adjustable).

      See Also

      • https://reactjs.org/docs/concurrent-mode-reference.html#suspenselist

      • https://reactjs.org/docs/concurrent-mode-patterns.html#suspenselist

    variable version

    const version: string;

      Functions

      function cache

      cache: <CachedFunction extends Function>(fn: CachedFunction) => CachedFunction;

        function cloneElement

        cloneElement: {
        <P extends HTMLAttributes<T>, T extends HTMLElement>(
        element: DetailedReactHTMLElement<P, T>,
        props?: P,
        ...children: ReactNode[]
        ): DetailedReactHTMLElement<P, T>;
        <P extends HTMLAttributes<T>, T extends HTMLElement>(
        element: ReactHTMLElement<T>,
        props?: P,
        ...children: ReactNode[]
        ): ReactHTMLElement<T>;
        <P extends SVGAttributes<T>, T extends SVGElement>(
        element: ReactSVGElement,
        props?: P,
        ...children: ReactNode[]
        ): ReactSVGElement;
        <P extends DOMAttributes<T>, T extends Element>(
        element: DOMElement<P, T>,
        props?: DOMAttributes<T> & P,
        ...children: ReactNode[]
        ): DOMElement<P, T>;
        <P>(
        element: FunctionComponentElement<P>,
        props?: Partial<P> & Attributes,
        ...children: ReactNode[]
        ): FunctionComponentElement<P>;
        <P, T extends Component<P, any, any>>(
        element: CElement<P, T>,
        props?: Partial<P> & ClassAttributes<T>,
        ...children: ReactNode[]
        ): CElement<P, T>;
        <P>(
        element: ReactElement<P, string | JSXElementConstructor<any>>,
        props?: Partial<P> & Attributes,
        ...children: ReactNode[]
        ): ReactElement<P, string | JSXElementConstructor<any>>;
        };

          function createContext

          createContext: <T>(defaultValue: T) => Context<T>;
          • Lets you create a Context that components can provide or read.

            Parameter defaultValue

            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.

            Example 1

            import { createContext } from 'react';
            const ThemeContext = createContext('light');

            See Also

          function createElement

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

            function createFactory

            createFactory: {
            <T extends HTMLElement>(type: keyof ReactHTML): HTMLFactory<T>;
            (type: keyof ReactSVG): SVGFactory;
            <P extends DOMAttributes<T>, T extends Element>(type: string): DOMFactory<P, T>;
            <P>(type: FunctionComponent<P>): FunctionComponentFactory<P>;
            <P, T extends Component<P, any, any>, C extends ComponentClass<P, any>>(
            type: ClassType<P, T, C>
            ): CFactory<P, T>;
            <P>(type: ComponentClass<P, any>): Factory<P>;
            };

              function createRef

              createRef: <T>() => RefObject<T>;

                function createServerContext

                createServerContext: <T extends ServerContextJSONValue>(
                globalName: string,
                defaultValue: T
                ) => ServerContext<T>;

                  function experimental_taintObjectReference

                  experimental_taintObjectReference: (
                  message: string | undefined,
                  object: Reference
                  ) => void;

                    function experimental_taintUniqueValue

                    experimental_taintUniqueValue: (
                    message: string | undefined,
                    lifetime: Reference,
                    value: TaintableUniqueValue
                    ) => void;

                      function experimental_useEffectEvent

                      experimental_useEffectEvent: <T extends Function>(event: T) => T;

                        function forwardRef

                        forwardRef: <T, P = {}>(
                        render: ForwardRefRenderFunction<T, P>
                        ) => ForwardRefExoticComponent<PropsWithoutRef<P> & RefAttributes<T>>;
                        • Lets your component expose a DOM node to a parent component using a ref.

                          Parameter render

                          See the ForwardRefRenderFunction.

                          T The type of the DOM node. P The props the component accepts, if any.

                          Example 1

                          interface Props {
                          children?: ReactNode;
                          type: "submit" | "button";
                          }
                          export const FancyButton = forwardRef<HTMLButtonElement, Props>((props, ref) => (
                          <button ref={ref} className="MyClassName" type={props.type}>
                          {props.children}
                          </button>
                          ));

                          See Also

                        function isValidElement

                        isValidElement: <P>(
                        object: {} | null | undefined
                        ) => object is ReactElement<P, string | JSXElementConstructor<any>>;

                          function lazy

                          lazy: <T extends ComponentType<any>>(
                          load: () => Promise<{ default: T }>
                          ) => LazyExoticComponent<T>;
                          • Lets you defer loading a component’s code until it is rendered for the first time.

                            Parameter load

                            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 1

                            import { lazy } from 'react';
                            const MarkdownPreview = lazy(() => import('./MarkdownPreview.js'));

                            See Also

                          function memo

                          memo: {
                          <P extends object>(
                          Component: FunctionComponent<P>,
                          propsAreEqual?: (prevProps: Readonly<P>, nextProps: Readonly<P>) => boolean
                          ): NamedExoticComponent<P>;
                          <T extends ComponentType<any>>(
                          Component: T,
                          propsAreEqual?: (
                          prevProps: Readonly<ComponentProps<T>>,
                          nextProps: Readonly<ComponentProps<T>>
                          ) => boolean
                          ): MemoExoticComponent<T>;
                          };
                          • Lets you skip re-rendering a component when its props are unchanged.

                            Parameter Component

                            The component to memoize.

                            Parameter propsAreEqual

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

                            Example 1

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

                            See Also

                          function startTransition

                          startTransition: (scope: TransitionFunction) => void;
                          • Similar to useTransition but allows uses where hooks are not available.

                            Parameter callback

                            A _synchronous_ function which causes state updates that can be deferred.

                          function unstable_useCacheRefresh

                          unstable_useCacheRefresh: () => () => void;

                            function use

                            use: <T>(usable: Usable<T>) => T;

                              function useCallback

                              useCallback: <T extends Function>(callback: T, deps: DependencyList) => T;

                              function useContext

                              useContext: {
                              <T>(context: Context<T>): T;
                              <T extends ServerContextJSONValue>(context: ServerContext<T>): 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.

                                16.8.0

                                See Also

                              function useDebugValue

                              useDebugValue: <T>(value: T, format?: (value: T) => any) => void;
                              • useDebugValue can be used to display a label for custom hooks in React DevTools.

                                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.

                                16.8.0

                                See Also

                              function useDeferredValue

                              useDeferredValue: <T>(value: T) => T;
                              • Returns a deferred version of the value that may “lag behind” it.

                                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.

                                Parameter value

                                The value that is going to be deferred

                                See Also

                              function useEffect

                              useEffect: (effect: EffectCallback, deps?: DependencyList) => void;
                              • Accepts a function that contains imperative, possibly effectful code.

                                Parameter effect

                                Imperative function that can return a cleanup function

                                Parameter deps

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

                                16.8.0

                                See Also

                              function useId

                              useId: () => string;

                                function useImperativeHandle

                                useImperativeHandle: <T, R extends T>(
                                ref: Ref<T> | undefined,
                                init: () => R,
                                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.

                                  useImperativeHandle should be used with React.forwardRef.

                                  16.8.0

                                  See Also

                                function useInsertionEffect

                                useInsertionEffect: (effect: EffectCallback, deps?: DependencyList) => void;

                                function useLayoutEffect

                                useLayoutEffect: (effect: EffectCallback, deps?: DependencyList) => void;
                                • 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.

                                  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.

                                  16.8.0

                                  See Also

                                function useMemo

                                useMemo: <T>(factory: () => T, deps: DependencyList) => T;

                                function useOptimistic

                                useOptimistic: {
                                <State>(passthrough: State): [
                                State,
                                (action: State | ((pendingState: State) => State)) => void
                                ];
                                <State, Action>(
                                passthrough: State,
                                reducer: (state: State, action: Action) => State
                                ): [State, (action: Action) => void];
                                };

                                  function useReducer

                                  useReducer: {
                                  <R extends ReducerWithoutAction<any>, I>(
                                  reducer: R,
                                  initializerArg: I,
                                  initializer: (arg: I) => ReducerStateWithoutAction<R>
                                  ): [ReducerStateWithoutAction<R>, DispatchWithoutAction];
                                  <R extends ReducerWithoutAction<any>>(
                                  reducer: R,
                                  initializerArg: ReducerStateWithoutAction<R>,
                                  initializer?: undefined
                                  ): [ReducerStateWithoutAction<R>, DispatchWithoutAction];
                                  <R extends Reducer<any, any>, I>(
                                  reducer: R,
                                  initializerArg: I & ReducerState<R>,
                                  initializer: (arg: I & ReducerState<R>) => ReducerState<R>
                                  ): [ReducerState<R>, Dispatch<ReducerAction<R>>];
                                  <R extends Reducer<any, any>, I>(
                                  reducer: R,
                                  initializerArg: I,
                                  initializer: (arg: I) => ReducerState<R>
                                  ): [ReducerState<R>, Dispatch<ReducerAction<R>>];
                                  <R extends Reducer<any, any>>(
                                  reducer: R,
                                  initialState: ReducerState<R>,
                                  initializer?: undefined
                                  ): [ReducerState<R>, Dispatch<ReducerAction<R>>];
                                  };
                                  • An alternative to useState.

                                    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.

                                    16.8.0

                                    See Also

                                  function useRef

                                  useRef: {
                                  <T>(initialValue: T): MutableRefObject<T>;
                                  <T>(initialValue: T): RefObject<T>;
                                  <T = undefined>(): 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.

                                    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.

                                    16.8.0

                                    See Also

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

                                    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.

                                    16.8.0

                                    See Also

                                  function useState

                                  useState: {
                                  <S>(initialState: S | (() => S)): [S, Dispatch<SetStateAction<S>>];
                                  <S = undefined>(): [S, Dispatch<SetStateAction<S>>];
                                  };

                                  function useSyncExternalStore

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

                                  function useTransition

                                  useTransition: () => [boolean, TransitionStartFunction];
                                  • 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.

                                    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 Also

                                  Classes

                                  class Component

                                  class Component<P, S> {}

                                    constructor

                                    constructor(props: P | Readonly<P>);

                                      constructor

                                      constructor(props: {}, context: any);
                                      • See Also

                                        Deprecated

                                      property context

                                      context: {};
                                      • 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.

                                        Example 1

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

                                        See Also

                                      property contextType

                                      static contextType?: Context<any>;
                                      • If set, this.context will be set at runtime to the current value of the given Context.

                                        Example 1

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

                                        See Also

                                      property props

                                      readonly props: Readonly<P>;

                                        property refs

                                        refs: { [key: string]: ReactInstance };
                                        • See Also

                                          Deprecated

                                        property state

                                        state: Readonly<S>;

                                          method forceUpdate

                                          forceUpdate: (callback?: () => void) => void;

                                            method render

                                            render: () => ReactNode;

                                              method setState

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

                                                class PureComponent

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

                                                  Interfaces

                                                  interface AbstractView

                                                  interface AbstractView {}

                                                    property document

                                                    document: Document;

                                                      property styleMedia

                                                      styleMedia: StyleMedia;

                                                        interface AllHTMLAttributes

                                                        interface AllHTMLAttributes<T> extends HTMLAttributes<T> {}

                                                          property accept

                                                          accept?: string | undefined;

                                                            property acceptCharset

                                                            acceptCharset?: string | undefined;

                                                              property action

                                                              action?:
                                                              | string
                                                              | undefined
                                                              | DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_FORM_ACTIONS[keyof DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_FORM_ACTIONS];

                                                                property allowFullScreen

                                                                allowFullScreen?: boolean | undefined;

                                                                  property allowTransparency

                                                                  allowTransparency?: boolean | undefined;

                                                                    property alt

                                                                    alt?: string | undefined;

                                                                      property as

                                                                      as?: string | undefined;

                                                                        property async

                                                                        async?: boolean | undefined;

                                                                          property autoComplete

                                                                          autoComplete?: string | undefined;

                                                                            property autoPlay

                                                                            autoPlay?: boolean | undefined;

                                                                              property capture

                                                                              capture?: boolean | 'user' | 'environment' | undefined;

                                                                                property cellPadding

                                                                                cellPadding?: number | string | undefined;

                                                                                  property cellSpacing

                                                                                  cellSpacing?: number | string | undefined;

                                                                                    property challenge

                                                                                    challenge?: string | undefined;

                                                                                      property charSet

                                                                                      charSet?: string | undefined;

                                                                                        property checked

                                                                                        checked?: boolean | undefined;

                                                                                          property cite

                                                                                          cite?: string | undefined;

                                                                                            property classID

                                                                                            classID?: string | undefined;

                                                                                              property cols

                                                                                              cols?: number | undefined;

                                                                                                property colSpan

                                                                                                colSpan?: number | undefined;

                                                                                                  property controls

                                                                                                  controls?: boolean | undefined;

                                                                                                    property coords

                                                                                                    coords?: string | undefined;

                                                                                                      property crossOrigin

                                                                                                      crossOrigin?: CrossOrigin;

                                                                                                        property data

                                                                                                        data?: string | undefined;

                                                                                                          property dateTime

                                                                                                          dateTime?: string | undefined;

                                                                                                            property default

                                                                                                            default?: boolean | undefined;

                                                                                                              property defer

                                                                                                              defer?: boolean | undefined;

                                                                                                                property disabled

                                                                                                                disabled?: boolean | undefined;

                                                                                                                  property download

                                                                                                                  download?: any;

                                                                                                                    property encType

                                                                                                                    encType?: string | undefined;

                                                                                                                      property form

                                                                                                                      form?: string | undefined;

                                                                                                                        property formAction

                                                                                                                        formAction?:
                                                                                                                        | string
                                                                                                                        | undefined
                                                                                                                        | DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_FORM_ACTIONS[keyof DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_FORM_ACTIONS];

                                                                                                                          property formEncType

                                                                                                                          formEncType?: string | undefined;

                                                                                                                            property formMethod

                                                                                                                            formMethod?: string | undefined;

                                                                                                                              property formNoValidate

                                                                                                                              formNoValidate?: boolean | undefined;

                                                                                                                                property formTarget

                                                                                                                                formTarget?: string | undefined;

                                                                                                                                  property frameBorder

                                                                                                                                  frameBorder?: number | string | undefined;

                                                                                                                                    property headers

                                                                                                                                    headers?: string | undefined;

                                                                                                                                      property height

                                                                                                                                      height?: number | string | undefined;

                                                                                                                                        property high

                                                                                                                                        high?: number | undefined;

                                                                                                                                          property href

                                                                                                                                          href?: string | undefined;

                                                                                                                                            property hrefLang

                                                                                                                                            hrefLang?: string | undefined;

                                                                                                                                              property htmlFor

                                                                                                                                              htmlFor?: string | undefined;

                                                                                                                                                property httpEquiv

                                                                                                                                                httpEquiv?: string | undefined;

                                                                                                                                                  property integrity

                                                                                                                                                  integrity?: string | undefined;

                                                                                                                                                    property keyParams

                                                                                                                                                    keyParams?: string | undefined;

                                                                                                                                                      property keyType

                                                                                                                                                      keyType?: string | undefined;

                                                                                                                                                        property kind

                                                                                                                                                        kind?: string | undefined;

                                                                                                                                                          property label

                                                                                                                                                          label?: string | undefined;

                                                                                                                                                            property list

                                                                                                                                                            list?: string | undefined;

                                                                                                                                                              property loop

                                                                                                                                                              loop?: boolean | undefined;

                                                                                                                                                                property low

                                                                                                                                                                low?: number | undefined;

                                                                                                                                                                  property manifest

                                                                                                                                                                  manifest?: string | undefined;

                                                                                                                                                                    property marginHeight

                                                                                                                                                                    marginHeight?: number | undefined;

                                                                                                                                                                      property marginWidth

                                                                                                                                                                      marginWidth?: number | undefined;

                                                                                                                                                                        property max

                                                                                                                                                                        max?: number | string | undefined;

                                                                                                                                                                          property maxLength

                                                                                                                                                                          maxLength?: number | undefined;

                                                                                                                                                                            property media

                                                                                                                                                                            media?: string | undefined;

                                                                                                                                                                              property mediaGroup

                                                                                                                                                                              mediaGroup?: string | undefined;

                                                                                                                                                                                property method

                                                                                                                                                                                method?: string | undefined;

                                                                                                                                                                                  property min

                                                                                                                                                                                  min?: number | string | undefined;

                                                                                                                                                                                    property minLength

                                                                                                                                                                                    minLength?: number | undefined;

                                                                                                                                                                                      property multiple

                                                                                                                                                                                      multiple?: boolean | undefined;

                                                                                                                                                                                        property muted

                                                                                                                                                                                        muted?: boolean | undefined;

                                                                                                                                                                                          property name

                                                                                                                                                                                          name?: string | undefined;

                                                                                                                                                                                            property noValidate

                                                                                                                                                                                            noValidate?: boolean | undefined;

                                                                                                                                                                                              property open

                                                                                                                                                                                              open?: boolean | undefined;

                                                                                                                                                                                                property optimum

                                                                                                                                                                                                optimum?: number | undefined;

                                                                                                                                                                                                  property pattern

                                                                                                                                                                                                  pattern?: string | undefined;

                                                                                                                                                                                                    property placeholder

                                                                                                                                                                                                    placeholder?: string | undefined;

                                                                                                                                                                                                      property playsInline

                                                                                                                                                                                                      playsInline?: boolean | undefined;

                                                                                                                                                                                                        property poster

                                                                                                                                                                                                        poster?: string | undefined;

                                                                                                                                                                                                          property preload

                                                                                                                                                                                                          preload?: string | undefined;

                                                                                                                                                                                                            property readOnly

                                                                                                                                                                                                            readOnly?: boolean | undefined;

                                                                                                                                                                                                              property required

                                                                                                                                                                                                              required?: boolean | undefined;

                                                                                                                                                                                                                property reversed

                                                                                                                                                                                                                reversed?: boolean | undefined;

                                                                                                                                                                                                                  property rows

                                                                                                                                                                                                                  rows?: number | undefined;

                                                                                                                                                                                                                    property rowSpan

                                                                                                                                                                                                                    rowSpan?: number | undefined;

                                                                                                                                                                                                                      property sandbox

                                                                                                                                                                                                                      sandbox?: string | undefined;

                                                                                                                                                                                                                        property scope

                                                                                                                                                                                                                        scope?: string | undefined;

                                                                                                                                                                                                                          property scoped

                                                                                                                                                                                                                          scoped?: boolean | undefined;

                                                                                                                                                                                                                            property scrolling

                                                                                                                                                                                                                            scrolling?: string | undefined;

                                                                                                                                                                                                                              property seamless

                                                                                                                                                                                                                              seamless?: boolean | undefined;

                                                                                                                                                                                                                                property selected

                                                                                                                                                                                                                                selected?: boolean | undefined;

                                                                                                                                                                                                                                  property shape

                                                                                                                                                                                                                                  shape?: string | undefined;

                                                                                                                                                                                                                                    property size

                                                                                                                                                                                                                                    size?: number | undefined;

                                                                                                                                                                                                                                      property sizes

                                                                                                                                                                                                                                      sizes?: string | undefined;

                                                                                                                                                                                                                                        property span

                                                                                                                                                                                                                                        span?: number | undefined;

                                                                                                                                                                                                                                          property src

                                                                                                                                                                                                                                          src?: string | undefined;

                                                                                                                                                                                                                                            property srcDoc

                                                                                                                                                                                                                                            srcDoc?: string | undefined;

                                                                                                                                                                                                                                              property srcLang

                                                                                                                                                                                                                                              srcLang?: string | undefined;

                                                                                                                                                                                                                                                property srcSet

                                                                                                                                                                                                                                                srcSet?: string | undefined;

                                                                                                                                                                                                                                                  property start

                                                                                                                                                                                                                                                  start?: number | undefined;

                                                                                                                                                                                                                                                    property step

                                                                                                                                                                                                                                                    step?: number | string | undefined;

                                                                                                                                                                                                                                                      property summary

                                                                                                                                                                                                                                                      summary?: string | undefined;

                                                                                                                                                                                                                                                        property target

                                                                                                                                                                                                                                                        target?: string | undefined;

                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                          type?: string | undefined;

                                                                                                                                                                                                                                                            property useMap

                                                                                                                                                                                                                                                            useMap?: string | undefined;

                                                                                                                                                                                                                                                              property value

                                                                                                                                                                                                                                                              value?: string | readonly string[] | number | undefined;

                                                                                                                                                                                                                                                                property width

                                                                                                                                                                                                                                                                width?: number | string | undefined;

                                                                                                                                                                                                                                                                  property wmode

                                                                                                                                                                                                                                                                  wmode?: string | undefined;

                                                                                                                                                                                                                                                                    property wrap

                                                                                                                                                                                                                                                                    wrap?: string | undefined;

                                                                                                                                                                                                                                                                      interface AnchorHTMLAttributes

                                                                                                                                                                                                                                                                      interface AnchorHTMLAttributes<T> extends HTMLAttributes<T> {}

                                                                                                                                                                                                                                                                        property download

                                                                                                                                                                                                                                                                        download?: any;

                                                                                                                                                                                                                                                                          property href

                                                                                                                                                                                                                                                                          href?: string | undefined;

                                                                                                                                                                                                                                                                            property hrefLang

                                                                                                                                                                                                                                                                            hrefLang?: string | undefined;

                                                                                                                                                                                                                                                                              property media

                                                                                                                                                                                                                                                                              media?: string | undefined;

                                                                                                                                                                                                                                                                                property ping

                                                                                                                                                                                                                                                                                ping?: string | undefined;

                                                                                                                                                                                                                                                                                  property referrerPolicy

                                                                                                                                                                                                                                                                                  referrerPolicy?: HTMLAttributeReferrerPolicy | undefined;

                                                                                                                                                                                                                                                                                    property target

                                                                                                                                                                                                                                                                                    target?: HTMLAttributeAnchorTarget | undefined;

                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                      type?: string | undefined;

                                                                                                                                                                                                                                                                                        interface AnimationEvent

                                                                                                                                                                                                                                                                                        interface AnimationEvent<T = Element>
                                                                                                                                                                                                                                                                                        extends SyntheticEvent<T, NativeAnimationEvent> {}

                                                                                                                                                                                                                                                                                          property animationName

                                                                                                                                                                                                                                                                                          animationName: string;

                                                                                                                                                                                                                                                                                            property elapsedTime

                                                                                                                                                                                                                                                                                            elapsedTime: number;

                                                                                                                                                                                                                                                                                              property pseudoElement

                                                                                                                                                                                                                                                                                              pseudoElement: string;

                                                                                                                                                                                                                                                                                                interface AreaHTMLAttributes

                                                                                                                                                                                                                                                                                                interface AreaHTMLAttributes<T> extends HTMLAttributes<T> {}

                                                                                                                                                                                                                                                                                                  property alt

                                                                                                                                                                                                                                                                                                  alt?: string | undefined;

                                                                                                                                                                                                                                                                                                    property coords

                                                                                                                                                                                                                                                                                                    coords?: string | undefined;

                                                                                                                                                                                                                                                                                                      property download

                                                                                                                                                                                                                                                                                                      download?: any;

                                                                                                                                                                                                                                                                                                        property href

                                                                                                                                                                                                                                                                                                        href?: string | undefined;

                                                                                                                                                                                                                                                                                                          property hrefLang

                                                                                                                                                                                                                                                                                                          hrefLang?: string | undefined;

                                                                                                                                                                                                                                                                                                            property media

                                                                                                                                                                                                                                                                                                            media?: string | undefined;

                                                                                                                                                                                                                                                                                                              property referrerPolicy

                                                                                                                                                                                                                                                                                                              referrerPolicy?: HTMLAttributeReferrerPolicy | undefined;

                                                                                                                                                                                                                                                                                                                property shape

                                                                                                                                                                                                                                                                                                                shape?: string | undefined;

                                                                                                                                                                                                                                                                                                                  property target

                                                                                                                                                                                                                                                                                                                  target?: string | undefined;

                                                                                                                                                                                                                                                                                                                    interface AriaAttributes

                                                                                                                                                                                                                                                                                                                    interface AriaAttributes {}

                                                                                                                                                                                                                                                                                                                      property "aria-activedescendant"

                                                                                                                                                                                                                                                                                                                      'aria-activedescendant'?: string | undefined;
                                                                                                                                                                                                                                                                                                                      • Identifies the currently active element when DOM focus is on a composite widget, textbox, group, or application.

                                                                                                                                                                                                                                                                                                                      property "aria-atomic"

                                                                                                                                                                                                                                                                                                                      'aria-atomic'?: Booleanish | 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.

                                                                                                                                                                                                                                                                                                                      property "aria-autocomplete"

                                                                                                                                                                                                                                                                                                                      'aria-autocomplete'?: 'none' | 'inline' | 'list' | 'both' | 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.

                                                                                                                                                                                                                                                                                                                      property "aria-braillelabel"

                                                                                                                                                                                                                                                                                                                      'aria-braillelabel'?: string | undefined;
                                                                                                                                                                                                                                                                                                                      • Defines a string value that labels the current element, which is intended to be converted into Braille.

                                                                                                                                                                                                                                                                                                                        See Also

                                                                                                                                                                                                                                                                                                                        • aria-label.

                                                                                                                                                                                                                                                                                                                      property "aria-brailleroledescription"

                                                                                                                                                                                                                                                                                                                      'aria-brailleroledescription'?: string | undefined;
                                                                                                                                                                                                                                                                                                                      • Defines a human-readable, author-localized abbreviated description for the role of an element, which is intended to be converted into Braille.

                                                                                                                                                                                                                                                                                                                        See Also

                                                                                                                                                                                                                                                                                                                        • aria-roledescription.

                                                                                                                                                                                                                                                                                                                      property "aria-busy"

                                                                                                                                                                                                                                                                                                                      'aria-busy'?: Booleanish | undefined;

                                                                                                                                                                                                                                                                                                                        property "aria-checked"

                                                                                                                                                                                                                                                                                                                        'aria-checked'?: boolean | 'false' | 'mixed' | 'true' | undefined;
                                                                                                                                                                                                                                                                                                                        • Indicates the current "checked" state of checkboxes, radio buttons, and other widgets.

                                                                                                                                                                                                                                                                                                                          See Also

                                                                                                                                                                                                                                                                                                                          • aria-pressed

                                                                                                                                                                                                                                                                                                                          • aria-selected.

                                                                                                                                                                                                                                                                                                                        property "aria-colcount"

                                                                                                                                                                                                                                                                                                                        'aria-colcount'?: number | undefined;
                                                                                                                                                                                                                                                                                                                        • Defines the total number of columns in a table, grid, or treegrid.

                                                                                                                                                                                                                                                                                                                          See Also

                                                                                                                                                                                                                                                                                                                          • aria-colindex.

                                                                                                                                                                                                                                                                                                                        property "aria-colindex"

                                                                                                                                                                                                                                                                                                                        'aria-colindex'?: number | undefined;
                                                                                                                                                                                                                                                                                                                        • Defines an element's column index or position with respect to the total number of columns within a table, grid, or treegrid.

                                                                                                                                                                                                                                                                                                                          See Also

                                                                                                                                                                                                                                                                                                                          • aria-colcount

                                                                                                                                                                                                                                                                                                                          • aria-colspan.

                                                                                                                                                                                                                                                                                                                        property "aria-colindextext"

                                                                                                                                                                                                                                                                                                                        'aria-colindextext'?: string | undefined;
                                                                                                                                                                                                                                                                                                                        • Defines a human readable text alternative of aria-colindex.

                                                                                                                                                                                                                                                                                                                          See Also

                                                                                                                                                                                                                                                                                                                          • aria-rowindextext.

                                                                                                                                                                                                                                                                                                                        property "aria-colspan"

                                                                                                                                                                                                                                                                                                                        'aria-colspan'?: number | undefined;
                                                                                                                                                                                                                                                                                                                        • Defines the number of columns spanned by a cell or gridcell within a table, grid, or treegrid.

                                                                                                                                                                                                                                                                                                                          See Also

                                                                                                                                                                                                                                                                                                                          • aria-colindex

                                                                                                                                                                                                                                                                                                                          • aria-rowspan.

                                                                                                                                                                                                                                                                                                                        property "aria-controls"

                                                                                                                                                                                                                                                                                                                        'aria-controls'?: string | undefined;
                                                                                                                                                                                                                                                                                                                        • Identifies the element (or elements) whose contents or presence are controlled by the current element.

                                                                                                                                                                                                                                                                                                                          See Also

                                                                                                                                                                                                                                                                                                                          • aria-owns.

                                                                                                                                                                                                                                                                                                                        property "aria-current"

                                                                                                                                                                                                                                                                                                                        'aria-current'?:
                                                                                                                                                                                                                                                                                                                        | boolean
                                                                                                                                                                                                                                                                                                                        | 'false'
                                                                                                                                                                                                                                                                                                                        | 'true'
                                                                                                                                                                                                                                                                                                                        | 'page'
                                                                                                                                                                                                                                                                                                                        | 'step'
                                                                                                                                                                                                                                                                                                                        | 'location'
                                                                                                                                                                                                                                                                                                                        | 'date'
                                                                                                                                                                                                                                                                                                                        | 'time'
                                                                                                                                                                                                                                                                                                                        | undefined;
                                                                                                                                                                                                                                                                                                                        • Indicates the element that represents the current item within a container or set of related elements.

                                                                                                                                                                                                                                                                                                                        property "aria-describedby"

                                                                                                                                                                                                                                                                                                                        'aria-describedby'?: string | undefined;
                                                                                                                                                                                                                                                                                                                        • Identifies the element (or elements) that describes the object.

                                                                                                                                                                                                                                                                                                                          See Also

                                                                                                                                                                                                                                                                                                                          • aria-labelledby

                                                                                                                                                                                                                                                                                                                        property "aria-description"

                                                                                                                                                                                                                                                                                                                        'aria-description'?: string | undefined;
                                                                                                                                                                                                                                                                                                                        • Defines a string value that describes or annotates the current element.

                                                                                                                                                                                                                                                                                                                          See Also

                                                                                                                                                                                                                                                                                                                          • related aria-describedby.

                                                                                                                                                                                                                                                                                                                        property "aria-details"

                                                                                                                                                                                                                                                                                                                        'aria-details'?: string | undefined;
                                                                                                                                                                                                                                                                                                                        • Identifies the element that provides a detailed, extended description for the object.

                                                                                                                                                                                                                                                                                                                          See Also

                                                                                                                                                                                                                                                                                                                          • aria-describedby.

                                                                                                                                                                                                                                                                                                                        property "aria-disabled"

                                                                                                                                                                                                                                                                                                                        'aria-disabled'?: Booleanish | undefined;
                                                                                                                                                                                                                                                                                                                        • Indicates that the element is perceivable but disabled, so it is not editable or otherwise operable.

                                                                                                                                                                                                                                                                                                                          See Also

                                                                                                                                                                                                                                                                                                                          • aria-hidden

                                                                                                                                                                                                                                                                                                                          • aria-readonly.

                                                                                                                                                                                                                                                                                                                        property "aria-dropeffect"

                                                                                                                                                                                                                                                                                                                        'aria-dropeffect'?:
                                                                                                                                                                                                                                                                                                                        | 'none'
                                                                                                                                                                                                                                                                                                                        | 'copy'
                                                                                                                                                                                                                                                                                                                        | 'execute'
                                                                                                                                                                                                                                                                                                                        | 'link'
                                                                                                                                                                                                                                                                                                                        | 'move'
                                                                                                                                                                                                                                                                                                                        | 'popup'
                                                                                                                                                                                                                                                                                                                        | undefined;
                                                                                                                                                                                                                                                                                                                        • Indicates what functions can be performed when a dragged object is released on the drop target.

                                                                                                                                                                                                                                                                                                                          Deprecated

                                                                                                                                                                                                                                                                                                                          in ARIA 1.1

                                                                                                                                                                                                                                                                                                                        property "aria-errormessage"

                                                                                                                                                                                                                                                                                                                        'aria-errormessage'?: string | undefined;
                                                                                                                                                                                                                                                                                                                        • Identifies the element that provides an error message for the object.

                                                                                                                                                                                                                                                                                                                          See Also

                                                                                                                                                                                                                                                                                                                          • aria-invalid

                                                                                                                                                                                                                                                                                                                          • aria-describedby.

                                                                                                                                                                                                                                                                                                                        property "aria-expanded"

                                                                                                                                                                                                                                                                                                                        'aria-expanded'?: Booleanish | undefined;
                                                                                                                                                                                                                                                                                                                        • Indicates whether the element, or another grouping element it controls, is currently expanded or collapsed.

                                                                                                                                                                                                                                                                                                                        property "aria-flowto"

                                                                                                                                                                                                                                                                                                                        'aria-flowto'?: string | 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.

                                                                                                                                                                                                                                                                                                                        property "aria-grabbed"

                                                                                                                                                                                                                                                                                                                        'aria-grabbed'?: Booleanish | undefined;
                                                                                                                                                                                                                                                                                                                        • Indicates an element's "grabbed" state in a drag-and-drop operation.

                                                                                                                                                                                                                                                                                                                          Deprecated

                                                                                                                                                                                                                                                                                                                          in ARIA 1.1

                                                                                                                                                                                                                                                                                                                        property "aria-haspopup"

                                                                                                                                                                                                                                                                                                                        'aria-haspopup'?:
                                                                                                                                                                                                                                                                                                                        | boolean
                                                                                                                                                                                                                                                                                                                        | 'false'
                                                                                                                                                                                                                                                                                                                        | 'true'
                                                                                                                                                                                                                                                                                                                        | 'menu'
                                                                                                                                                                                                                                                                                                                        | 'listbox'
                                                                                                                                                                                                                                                                                                                        | 'tree'
                                                                                                                                                                                                                                                                                                                        | 'grid'
                                                                                                                                                                                                                                                                                                                        | 'dialog'
                                                                                                                                                                                                                                                                                                                        | undefined;
                                                                                                                                                                                                                                                                                                                        • Indicates the availability and type of interactive popup element, such as menu or dialog, that can be triggered by an element.

                                                                                                                                                                                                                                                                                                                        property "aria-hidden"

                                                                                                                                                                                                                                                                                                                        'aria-hidden'?: Booleanish | undefined;
                                                                                                                                                                                                                                                                                                                        • Indicates whether the element is exposed to an accessibility API.

                                                                                                                                                                                                                                                                                                                          See Also

                                                                                                                                                                                                                                                                                                                          • aria-disabled.

                                                                                                                                                                                                                                                                                                                        property "aria-invalid"

                                                                                                                                                                                                                                                                                                                        'aria-invalid'?: boolean | 'false' | 'true' | 'grammar' | 'spelling' | undefined;
                                                                                                                                                                                                                                                                                                                        • Indicates the entered value does not conform to the format expected by the application.

                                                                                                                                                                                                                                                                                                                          See Also

                                                                                                                                                                                                                                                                                                                          • aria-errormessage.

                                                                                                                                                                                                                                                                                                                        property "aria-keyshortcuts"

                                                                                                                                                                                                                                                                                                                        'aria-keyshortcuts'?: string | undefined;
                                                                                                                                                                                                                                                                                                                        • Indicates keyboard shortcuts that an author has implemented to activate or give focus to an element.

                                                                                                                                                                                                                                                                                                                        property "aria-label"

                                                                                                                                                                                                                                                                                                                        'aria-label'?: string | undefined;
                                                                                                                                                                                                                                                                                                                        • Defines a string value that labels the current element.

                                                                                                                                                                                                                                                                                                                          See Also

                                                                                                                                                                                                                                                                                                                          • aria-labelledby.

                                                                                                                                                                                                                                                                                                                        property "aria-labelledby"

                                                                                                                                                                                                                                                                                                                        'aria-labelledby'?: string | undefined;
                                                                                                                                                                                                                                                                                                                        • Identifies the element (or elements) that labels the current element.

                                                                                                                                                                                                                                                                                                                          See Also

                                                                                                                                                                                                                                                                                                                          • aria-describedby.

                                                                                                                                                                                                                                                                                                                        property "aria-level"

                                                                                                                                                                                                                                                                                                                        'aria-level'?: number | undefined;
                                                                                                                                                                                                                                                                                                                        • Defines the hierarchical level of an element within a structure.

                                                                                                                                                                                                                                                                                                                        property "aria-live"

                                                                                                                                                                                                                                                                                                                        'aria-live'?: 'off' | 'assertive' | 'polite' | 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.

                                                                                                                                                                                                                                                                                                                        property "aria-modal"

                                                                                                                                                                                                                                                                                                                        'aria-modal'?: Booleanish | undefined;
                                                                                                                                                                                                                                                                                                                        • Indicates whether an element is modal when displayed.

                                                                                                                                                                                                                                                                                                                        property "aria-multiline"

                                                                                                                                                                                                                                                                                                                        'aria-multiline'?: Booleanish | undefined;
                                                                                                                                                                                                                                                                                                                        • Indicates whether a text box accepts multiple lines of input or only a single line.

                                                                                                                                                                                                                                                                                                                        property "aria-multiselectable"

                                                                                                                                                                                                                                                                                                                        'aria-multiselectable'?: Booleanish | undefined;
                                                                                                                                                                                                                                                                                                                        • Indicates that the user may select more than one item from the current selectable descendants.

                                                                                                                                                                                                                                                                                                                        property "aria-orientation"

                                                                                                                                                                                                                                                                                                                        'aria-orientation'?: 'horizontal' | 'vertical' | undefined;
                                                                                                                                                                                                                                                                                                                        • Indicates whether the element's orientation is horizontal, vertical, or unknown/ambiguous.

                                                                                                                                                                                                                                                                                                                        property "aria-owns"

                                                                                                                                                                                                                                                                                                                        'aria-owns'?: string | 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.

                                                                                                                                                                                                                                                                                                                          See Also

                                                                                                                                                                                                                                                                                                                          • aria-controls.

                                                                                                                                                                                                                                                                                                                        property "aria-placeholder"

                                                                                                                                                                                                                                                                                                                        'aria-placeholder'?: 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.

                                                                                                                                                                                                                                                                                                                        property "aria-posinset"

                                                                                                                                                                                                                                                                                                                        'aria-posinset'?: number | 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.

                                                                                                                                                                                                                                                                                                                          See Also

                                                                                                                                                                                                                                                                                                                          • aria-setsize.

                                                                                                                                                                                                                                                                                                                        property "aria-pressed"

                                                                                                                                                                                                                                                                                                                        'aria-pressed'?: boolean | 'false' | 'mixed' | 'true' | undefined;
                                                                                                                                                                                                                                                                                                                        • Indicates the current "pressed" state of toggle buttons.

                                                                                                                                                                                                                                                                                                                          See Also

                                                                                                                                                                                                                                                                                                                          • aria-checked

                                                                                                                                                                                                                                                                                                                          • aria-selected.

                                                                                                                                                                                                                                                                                                                        property "aria-readonly"

                                                                                                                                                                                                                                                                                                                        'aria-readonly'?: Booleanish | undefined;
                                                                                                                                                                                                                                                                                                                        • Indicates that the element is not editable, but is otherwise operable.

                                                                                                                                                                                                                                                                                                                          See Also

                                                                                                                                                                                                                                                                                                                          • aria-disabled.

                                                                                                                                                                                                                                                                                                                        property "aria-relevant"

                                                                                                                                                                                                                                                                                                                        'aria-relevant'?:
                                                                                                                                                                                                                                                                                                                        | 'additions'
                                                                                                                                                                                                                                                                                                                        | 'additions removals'
                                                                                                                                                                                                                                                                                                                        | 'additions text'
                                                                                                                                                                                                                                                                                                                        | 'all'
                                                                                                                                                                                                                                                                                                                        | 'removals'
                                                                                                                                                                                                                                                                                                                        | 'removals additions'
                                                                                                                                                                                                                                                                                                                        | 'removals text'
                                                                                                                                                                                                                                                                                                                        | 'text'
                                                                                                                                                                                                                                                                                                                        | 'text additions'
                                                                                                                                                                                                                                                                                                                        | 'text removals'
                                                                                                                                                                                                                                                                                                                        | undefined;
                                                                                                                                                                                                                                                                                                                        • Indicates what notifications the user agent will trigger when the accessibility tree within a live region is modified.

                                                                                                                                                                                                                                                                                                                          See Also

                                                                                                                                                                                                                                                                                                                          • aria-atomic.

                                                                                                                                                                                                                                                                                                                        property "aria-required"

                                                                                                                                                                                                                                                                                                                        'aria-required'?: Booleanish | undefined;
                                                                                                                                                                                                                                                                                                                        • Indicates that user input is required on the element before a form may be submitted.

                                                                                                                                                                                                                                                                                                                        property "aria-roledescription"

                                                                                                                                                                                                                                                                                                                        'aria-roledescription'?: string | undefined;
                                                                                                                                                                                                                                                                                                                        • Defines a human-readable, author-localized description for the role of an element.

                                                                                                                                                                                                                                                                                                                        property "aria-rowcount"

                                                                                                                                                                                                                                                                                                                        'aria-rowcount'?: number | undefined;
                                                                                                                                                                                                                                                                                                                        • Defines the total number of rows in a table, grid, or treegrid.

                                                                                                                                                                                                                                                                                                                          See Also

                                                                                                                                                                                                                                                                                                                          • aria-rowindex.

                                                                                                                                                                                                                                                                                                                        property "aria-rowindex"

                                                                                                                                                                                                                                                                                                                        'aria-rowindex'?: number | undefined;
                                                                                                                                                                                                                                                                                                                        • Defines an element's row index or position with respect to the total number of rows within a table, grid, or treegrid.

                                                                                                                                                                                                                                                                                                                          See Also

                                                                                                                                                                                                                                                                                                                          • aria-rowcount

                                                                                                                                                                                                                                                                                                                          • aria-rowspan.

                                                                                                                                                                                                                                                                                                                        property "aria-rowindextext"

                                                                                                                                                                                                                                                                                                                        'aria-rowindextext'?: string | undefined;
                                                                                                                                                                                                                                                                                                                        • Defines a human readable text alternative of aria-rowindex.

                                                                                                                                                                                                                                                                                                                          See Also

                                                                                                                                                                                                                                                                                                                          • aria-colindextext.

                                                                                                                                                                                                                                                                                                                        property "aria-rowspan"

                                                                                                                                                                                                                                                                                                                        'aria-rowspan'?: number | undefined;
                                                                                                                                                                                                                                                                                                                        • Defines the number of rows spanned by a cell or gridcell within a table, grid, or treegrid.

                                                                                                                                                                                                                                                                                                                          See Also

                                                                                                                                                                                                                                                                                                                          • aria-rowindex

                                                                                                                                                                                                                                                                                                                          • aria-colspan.

                                                                                                                                                                                                                                                                                                                        property "aria-selected"

                                                                                                                                                                                                                                                                                                                        'aria-selected'?: Booleanish | undefined;
                                                                                                                                                                                                                                                                                                                        • Indicates the current "selected" state of various widgets.

                                                                                                                                                                                                                                                                                                                          See Also

                                                                                                                                                                                                                                                                                                                          • aria-checked

                                                                                                                                                                                                                                                                                                                          • aria-pressed.

                                                                                                                                                                                                                                                                                                                        property "aria-setsize"

                                                                                                                                                                                                                                                                                                                        'aria-setsize'?: number | 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.

                                                                                                                                                                                                                                                                                                                          See Also

                                                                                                                                                                                                                                                                                                                          • aria-posinset.

                                                                                                                                                                                                                                                                                                                        property "aria-sort"

                                                                                                                                                                                                                                                                                                                        'aria-sort'?: 'none' | 'ascending' | 'descending' | 'other' | undefined;
                                                                                                                                                                                                                                                                                                                        • Indicates if items in a table or grid are sorted in ascending or descending order.

                                                                                                                                                                                                                                                                                                                        property "aria-valuemax"

                                                                                                                                                                                                                                                                                                                        'aria-valuemax'?: number | undefined;
                                                                                                                                                                                                                                                                                                                        • Defines the maximum allowed value for a range widget.

                                                                                                                                                                                                                                                                                                                        property "aria-valuemin"

                                                                                                                                                                                                                                                                                                                        'aria-valuemin'?: number | undefined;
                                                                                                                                                                                                                                                                                                                        • Defines the minimum allowed value for a range widget.

                                                                                                                                                                                                                                                                                                                        property "aria-valuenow"

                                                                                                                                                                                                                                                                                                                        'aria-valuenow'?: number | undefined;
                                                                                                                                                                                                                                                                                                                        • Defines the current value for a range widget.

                                                                                                                                                                                                                                                                                                                          See Also

                                                                                                                                                                                                                                                                                                                          • aria-valuetext.

                                                                                                                                                                                                                                                                                                                        property "aria-valuetext"

                                                                                                                                                                                                                                                                                                                        'aria-valuetext'?: string | undefined;
                                                                                                                                                                                                                                                                                                                        • Defines the human readable text alternative of aria-valuenow for a range widget.

                                                                                                                                                                                                                                                                                                                        interface AudioHTMLAttributes

                                                                                                                                                                                                                                                                                                                        interface AudioHTMLAttributes<T> extends MediaHTMLAttributes<T> {}

                                                                                                                                                                                                                                                                                                                          interface BaseHTMLAttributes

                                                                                                                                                                                                                                                                                                                          interface BaseHTMLAttributes<T> extends HTMLAttributes<T> {}

                                                                                                                                                                                                                                                                                                                            property href

                                                                                                                                                                                                                                                                                                                            href?: string | undefined;

                                                                                                                                                                                                                                                                                                                              property target

                                                                                                                                                                                                                                                                                                                              target?: string | undefined;

                                                                                                                                                                                                                                                                                                                                interface BaseSyntheticEvent

                                                                                                                                                                                                                                                                                                                                interface BaseSyntheticEvent<E = object, C = any, T = any> {}

                                                                                                                                                                                                                                                                                                                                  property bubbles

                                                                                                                                                                                                                                                                                                                                  bubbles: boolean;

                                                                                                                                                                                                                                                                                                                                    property cancelable

                                                                                                                                                                                                                                                                                                                                    cancelable: boolean;

                                                                                                                                                                                                                                                                                                                                      property currentTarget

                                                                                                                                                                                                                                                                                                                                      currentTarget: C;

                                                                                                                                                                                                                                                                                                                                        property defaultPrevented

                                                                                                                                                                                                                                                                                                                                        defaultPrevented: boolean;

                                                                                                                                                                                                                                                                                                                                          property eventPhase

                                                                                                                                                                                                                                                                                                                                          eventPhase: number;

                                                                                                                                                                                                                                                                                                                                            property isTrusted

                                                                                                                                                                                                                                                                                                                                            isTrusted: boolean;

                                                                                                                                                                                                                                                                                                                                              property nativeEvent

                                                                                                                                                                                                                                                                                                                                              nativeEvent: E;

                                                                                                                                                                                                                                                                                                                                                property target

                                                                                                                                                                                                                                                                                                                                                target: T;

                                                                                                                                                                                                                                                                                                                                                  property timeStamp

                                                                                                                                                                                                                                                                                                                                                  timeStamp: number;

                                                                                                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                                                                                                    type: string;

                                                                                                                                                                                                                                                                                                                                                      method isDefaultPrevented

                                                                                                                                                                                                                                                                                                                                                      isDefaultPrevented: () => boolean;

                                                                                                                                                                                                                                                                                                                                                        method isPropagationStopped

                                                                                                                                                                                                                                                                                                                                                        isPropagationStopped: () => boolean;

                                                                                                                                                                                                                                                                                                                                                          method persist

                                                                                                                                                                                                                                                                                                                                                          persist: () => void;

                                                                                                                                                                                                                                                                                                                                                            method preventDefault

                                                                                                                                                                                                                                                                                                                                                            preventDefault: () => void;

                                                                                                                                                                                                                                                                                                                                                              method stopPropagation

                                                                                                                                                                                                                                                                                                                                                              stopPropagation: () => void;

                                                                                                                                                                                                                                                                                                                                                                interface BlockquoteHTMLAttributes

                                                                                                                                                                                                                                                                                                                                                                interface BlockquoteHTMLAttributes<T> extends HTMLAttributes<T> {}

                                                                                                                                                                                                                                                                                                                                                                  property cite

                                                                                                                                                                                                                                                                                                                                                                  cite?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                    interface ButtonHTMLAttributes

                                                                                                                                                                                                                                                                                                                                                                    interface ButtonHTMLAttributes<T> extends HTMLAttributes<T> {}

                                                                                                                                                                                                                                                                                                                                                                      property disabled

                                                                                                                                                                                                                                                                                                                                                                      disabled?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                        property form

                                                                                                                                                                                                                                                                                                                                                                        form?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                          property formAction

                                                                                                                                                                                                                                                                                                                                                                          formAction?:
                                                                                                                                                                                                                                                                                                                                                                          | string
                                                                                                                                                                                                                                                                                                                                                                          | DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_FORM_ACTIONS[keyof DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_FORM_ACTIONS]
                                                                                                                                                                                                                                                                                                                                                                          | undefined;

                                                                                                                                                                                                                                                                                                                                                                            property formEncType

                                                                                                                                                                                                                                                                                                                                                                            formEncType?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                              property formMethod

                                                                                                                                                                                                                                                                                                                                                                              formMethod?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                property formNoValidate

                                                                                                                                                                                                                                                                                                                                                                                formNoValidate?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                  property formTarget

                                                                                                                                                                                                                                                                                                                                                                                  formTarget?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                    property name

                                                                                                                                                                                                                                                                                                                                                                                    name?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                                                                                                      type?: 'submit' | 'reset' | 'button' | undefined;

                                                                                                                                                                                                                                                                                                                                                                                        property value

                                                                                                                                                                                                                                                                                                                                                                                        value?: string | readonly string[] | number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                          interface CanvasHTMLAttributes

                                                                                                                                                                                                                                                                                                                                                                                          interface CanvasHTMLAttributes<T> extends HTMLAttributes<T> {}

                                                                                                                                                                                                                                                                                                                                                                                            property height

                                                                                                                                                                                                                                                                                                                                                                                            height?: number | string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                              property width

                                                                                                                                                                                                                                                                                                                                                                                              width?: number | string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                interface ChangeEvent

                                                                                                                                                                                                                                                                                                                                                                                                interface ChangeEvent<T = Element> extends SyntheticEvent<T> {}

                                                                                                                                                                                                                                                                                                                                                                                                  property target

                                                                                                                                                                                                                                                                                                                                                                                                  target: EventTarget & T;

                                                                                                                                                                                                                                                                                                                                                                                                    interface ChildContextProvider

                                                                                                                                                                                                                                                                                                                                                                                                    interface ChildContextProvider<CC> {}

                                                                                                                                                                                                                                                                                                                                                                                                      method getChildContext

                                                                                                                                                                                                                                                                                                                                                                                                      getChildContext: () => CC;

                                                                                                                                                                                                                                                                                                                                                                                                        interface ClassAttributes

                                                                                                                                                                                                                                                                                                                                                                                                        interface ClassAttributes<T> extends RefAttributes<T> {}
                                                                                                                                                                                                                                                                                                                                                                                                        • Represents the built-in attributes available to class components.

                                                                                                                                                                                                                                                                                                                                                                                                        interface ClassicComponent

                                                                                                                                                                                                                                                                                                                                                                                                        interface ClassicComponent<P = {}, S = {}> extends Component<P, S> {}
                                                                                                                                                                                                                                                                                                                                                                                                        • See Also

                                                                                                                                                                                                                                                                                                                                                                                                          Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                          Use ClassicComponent from create-react-class

                                                                                                                                                                                                                                                                                                                                                                                                        method getInitialState

                                                                                                                                                                                                                                                                                                                                                                                                        getInitialState: () => S;

                                                                                                                                                                                                                                                                                                                                                                                                          method isMounted

                                                                                                                                                                                                                                                                                                                                                                                                          isMounted: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                            method replaceState

                                                                                                                                                                                                                                                                                                                                                                                                            replaceState: (nextState: S, callback?: () => void) => void;

                                                                                                                                                                                                                                                                                                                                                                                                              interface ClassicComponentClass

                                                                                                                                                                                                                                                                                                                                                                                                              interface ClassicComponentClass<P = {}> extends ComponentClass<P> {}
                                                                                                                                                                                                                                                                                                                                                                                                              • See Also

                                                                                                                                                                                                                                                                                                                                                                                                                Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                Use ClassicComponentClass from create-react-class

                                                                                                                                                                                                                                                                                                                                                                                                              method getDefaultProps

                                                                                                                                                                                                                                                                                                                                                                                                              getDefaultProps: () => P;

                                                                                                                                                                                                                                                                                                                                                                                                                construct signature

                                                                                                                                                                                                                                                                                                                                                                                                                new (props: P, context?: any): ClassicComponent<P, ComponentState>;

                                                                                                                                                                                                                                                                                                                                                                                                                  interface ClipboardEvent

                                                                                                                                                                                                                                                                                                                                                                                                                  interface ClipboardEvent<T = Element>
                                                                                                                                                                                                                                                                                                                                                                                                                  extends SyntheticEvent<T, NativeClipboardEvent> {}

                                                                                                                                                                                                                                                                                                                                                                                                                    property clipboardData

                                                                                                                                                                                                                                                                                                                                                                                                                    clipboardData: DataTransfer;

                                                                                                                                                                                                                                                                                                                                                                                                                      interface ColgroupHTMLAttributes

                                                                                                                                                                                                                                                                                                                                                                                                                      interface ColgroupHTMLAttributes<T> extends HTMLAttributes<T> {}

                                                                                                                                                                                                                                                                                                                                                                                                                        property span

                                                                                                                                                                                                                                                                                                                                                                                                                        span?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                          interface ColHTMLAttributes

                                                                                                                                                                                                                                                                                                                                                                                                                          interface ColHTMLAttributes<T> extends HTMLAttributes<T> {}

                                                                                                                                                                                                                                                                                                                                                                                                                            property span

                                                                                                                                                                                                                                                                                                                                                                                                                            span?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                              property width

                                                                                                                                                                                                                                                                                                                                                                                                                              width?: number | string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                interface Component

                                                                                                                                                                                                                                                                                                                                                                                                                                interface Component<P = {}, S = {}, SS = any> extends ComponentLifecycle<P, S, SS> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ComponentClass

                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ComponentClass<P = {}, S = ComponentState> extends StaticLifecycle<P, S> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                  • Represents a component class in React.

                                                                                                                                                                                                                                                                                                                                                                                                                                    P The props the component accepts. S The internal state of the component.

                                                                                                                                                                                                                                                                                                                                                                                                                                  property childContextTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                  childContextTypes?: ValidationMap<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                  • See Also

                                                                                                                                                                                                                                                                                                                                                                                                                                    Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                  property contextType

                                                                                                                                                                                                                                                                                                                                                                                                                                  contextType?: Context<any> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                    property contextTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                    contextTypes?: ValidationMap<any> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                    property defaultProps

                                                                                                                                                                                                                                                                                                                                                                                                                                    defaultProps?: Partial<P> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Used to define default values for the props accepted by the component.

                                                                                                                                                                                                                                                                                                                                                                                                                                      See Also

                                                                                                                                                                                                                                                                                                                                                                                                                                    property displayName

                                                                                                                                                                                                                                                                                                                                                                                                                                    displayName?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Used in debugging messages. You might want to set it explicitly if you want to display a different name for debugging purposes.

                                                                                                                                                                                                                                                                                                                                                                                                                                      See Also

                                                                                                                                                                                                                                                                                                                                                                                                                                    property propTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                    propTypes?: WeakValidationMap<P> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Used to declare the types of the props accepted by the component. These types will be checked during rendering and in development only.

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

                                                                                                                                                                                                                                                                                                                                                                                                                                      See Also

                                                                                                                                                                                                                                                                                                                                                                                                                                    construct signature

                                                                                                                                                                                                                                                                                                                                                                                                                                    new (props: P, context?: any): Component<P, S>;

                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ComponentElement

                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ComponentElement<P, T extends Component<P, ComponentState>>
                                                                                                                                                                                                                                                                                                                                                                                                                                      extends ReactElement<P, ComponentClass<P>> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                        property ref

                                                                                                                                                                                                                                                                                                                                                                                                                                        ref?: LegacyRef<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ComponentLifecycle

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

                                                                                                                                                                                                                                                                                                                                                                                                                                            method componentDidCatch

                                                                                                                                                                                                                                                                                                                                                                                                                                            componentDidCatch: (error: Error, errorInfo: ErrorInfo) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                            • Catches exceptions generated in descendant components. Unhandled exceptions will cause the entire component tree to unmount.

                                                                                                                                                                                                                                                                                                                                                                                                                                            method componentDidMount

                                                                                                                                                                                                                                                                                                                                                                                                                                            componentDidMount: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                            • Called immediately after a component is mounted. Setting state here will trigger re-rendering.

                                                                                                                                                                                                                                                                                                                                                                                                                                            method componentWillUnmount

                                                                                                                                                                                                                                                                                                                                                                                                                                            componentWillUnmount: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                            • 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.

                                                                                                                                                                                                                                                                                                                                                                                                                                            method shouldComponentUpdate

                                                                                                                                                                                                                                                                                                                                                                                                                                            shouldComponentUpdate: (
                                                                                                                                                                                                                                                                                                                                                                                                                                            nextProps: Readonly<P>,
                                                                                                                                                                                                                                                                                                                                                                                                                                            nextState: Readonly<S>,
                                                                                                                                                                                                                                                                                                                                                                                                                                            nextContext: any
                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                            • Called to determine whether the change in props and state should trigger a re-render.

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

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

                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ComponentSpec

                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ComponentSpec<P, S> extends Mixin<P, S> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                            • See Also

                                                                                                                                                                                                                                                                                                                                                                                                                                              Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                            method render

                                                                                                                                                                                                                                                                                                                                                                                                                                            render: () => ReactNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                              index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                              [propertyName: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                interface CompositionEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                interface CompositionEvent<T = Element>
                                                                                                                                                                                                                                                                                                                                                                                                                                                extends SyntheticEvent<T, NativeCompositionEvent> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                  property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                  data: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ConsumerProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ConsumerProps<T> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Describes the props accepted by a Context Consumer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                      T The type of the value the context provides.

                                                                                                                                                                                                                                                                                                                                                                                                                                                    property children

                                                                                                                                                                                                                                                                                                                                                                                                                                                    children: (value: T) => ReactNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface Context

                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface Context<T> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Context lets components pass information deep down without explicitly passing props.

                                                                                                                                                                                                                                                                                                                                                                                                                                                        Created from createContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                        Example 1

                                                                                                                                                                                                                                                                                                                                                                                                                                                        import { createContext } from 'react';
                                                                                                                                                                                                                                                                                                                                                                                                                                                        const ThemeContext = createContext('light');

                                                                                                                                                                                                                                                                                                                                                                                                                                                        See Also

                                                                                                                                                                                                                                                                                                                                                                                                                                                      property Consumer

                                                                                                                                                                                                                                                                                                                                                                                                                                                      Consumer: Consumer<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property displayName

                                                                                                                                                                                                                                                                                                                                                                                                                                                        displayName?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Used in debugging messages. You might want to set it explicitly if you want to display a different name for debugging purposes.

                                                                                                                                                                                                                                                                                                                                                                                                                                                          See Also

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property Provider

                                                                                                                                                                                                                                                                                                                                                                                                                                                        Provider: Provider<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface CSSProperties

                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface CSSProperties extends CSS.Properties<string | number> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface DataHTMLAttributes

                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface DataHTMLAttributes<T> extends HTMLAttributes<T> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                              property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                              value?: string | readonly string[] | number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface DelHTMLAttributes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface DelHTMLAttributes<T> extends HTMLAttributes<T> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property cite

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  cite?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property dateTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    dateTime?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface DeprecatedLifecycle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface DeprecatedLifecycle<P, S> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method componentWillMount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        componentWillMount: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method componentWillReceiveProps

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method componentWillUpdate

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method UNSAFE_componentWillMount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        UNSAFE_componentWillMount: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method UNSAFE_componentWillReceiveProps

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method UNSAFE_componentWillUpdate

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface DetailedHTMLFactory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface DetailedHTMLFactory<P extends HTMLAttributes<T>, T extends HTMLElement>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        extends DOMFactory<P, T> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          props?: (ClassAttributes<T> & P) | null,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ...children: ReactNode[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): DetailedReactHTMLElement<P, T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface DetailedReactHTMLElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface DetailedReactHTMLElement<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            P extends HTMLAttributes<T>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            T extends HTMLElement
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            > extends DOMElement<P, T> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type: keyof ReactHTML;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface DetailsHTMLAttributes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface DetailsHTMLAttributes<T> extends HTMLAttributes<T> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  name?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property onToggle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onToggle?: ReactEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property open

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      open?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface DialogHTMLAttributes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface DialogHTMLAttributes<T> extends HTMLAttributes<T> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property onCancel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          onCancel?: ReactEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property onClose

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onClose?: ReactEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property open

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              open?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface DirectionalSuspenseListProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface DirectionalSuspenseListProps extends SuspenseListCommonProps {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property revealOrder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  revealOrder: 'forwards' | 'backwards';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Defines the order in which the SuspenseList children should be revealed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property tail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  tail?: SuspenseListTailMode | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Dictates how unloaded items in a SuspenseList is shown.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - By default, SuspenseList will show all fallbacks in the list. - collapsed shows only the next fallback in the list. - hidden doesn’t show any unloaded items.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_FORM_ACTIONS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_FORM_ACTIONS {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • 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.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_FORM_ACTIONS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_FORM_ACTIONS {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property functions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    functions: (formData: FormData) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_REACT_NODES

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_REACT_NODES {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Different release channels declare additional types of ReactNode this particular release channel accepts. App or library types should never augment this interface.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_REACT_NODES

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_REACT_NODES {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property promises

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        promises: PromiseLikeOfReactNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface DOMAttributes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface DOMAttributes<T> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property children

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            children?: ReactNode | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property dangerouslySetInnerHTML

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              dangerouslySetInnerHTML?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              // Should be InnerHTML['innerHTML'].
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              // But unfortunately we're mixing renderer-specific type declarations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              __html: string | TrustedHTML;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property onAbort

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onAbort?: ReactEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property onAbortCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  onAbortCapture?: ReactEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property onAnimationEnd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onAnimationEnd?: AnimationEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property onAnimationEndCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onAnimationEndCapture?: AnimationEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onAnimationIteration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onAnimationIteration?: AnimationEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property onAnimationIterationCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          onAnimationIterationCapture?: AnimationEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property onAnimationStart

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onAnimationStart?: AnimationEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property onAnimationStartCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              onAnimationStartCapture?: AnimationEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property onAuxClick

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onAuxClick?: MouseEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property onAuxClickCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  onAuxClickCapture?: MouseEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property onBeforeInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onBeforeInput?: FormEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property onBeforeInputCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onBeforeInputCapture?: FormEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onBlur

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onBlur?: FocusEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property onBlurCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          onBlurCapture?: FocusEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property onCanPlay

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onCanPlay?: ReactEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property onCanPlayCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              onCanPlayCapture?: ReactEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property onCanPlayThrough

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onCanPlayThrough?: ReactEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property onCanPlayThroughCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  onCanPlayThroughCapture?: ReactEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property onChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onChange?: FormEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property onChangeCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onChangeCapture?: FormEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onClick

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onClick?: MouseEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property onClickCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          onClickCapture?: MouseEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property onCompositionEnd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onCompositionEnd?: CompositionEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property onCompositionEndCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              onCompositionEndCapture?: CompositionEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property onCompositionStart

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onCompositionStart?: CompositionEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property onCompositionStartCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  onCompositionStartCapture?: CompositionEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property onCompositionUpdate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onCompositionUpdate?: CompositionEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property onCompositionUpdateCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onCompositionUpdateCapture?: CompositionEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onContextMenu

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onContextMenu?: MouseEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property onContextMenuCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          onContextMenuCapture?: MouseEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property onCopy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onCopy?: ClipboardEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property onCopyCapture