@types/react

  • Version 17.0.38
  • Published
  • 177 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: ReactChildren;

    variable Fragment

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

      variable Profiler

      const Profiler: ExoticComponent<ProfilerProps>;

        variable StrictMode

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

          variable Suspense

          const Suspense: ExoticComponent<SuspenseProps>;
          • This feature is not yet available for server-side rendering. Suspense support will be added in a later release.

          variable SuspenseList

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

          const UNDEFINED_VOID_ONLY: Symbol;

            variable version

            const version: string;

              Functions

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

                  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 {}>(
                  type: ClassType<P, ClassicComponent<P, any>, ClassicComponentClass<P>>,
                  props?: ClassAttributes<ClassicComponent<P, any>> & P,
                  ...children: ReactNode[]
                  ): CElement<P, ClassicComponent<P, any>>;
                  <
                  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>(
                    type: ClassType<P, ClassicComponent<P, any>, ClassicComponentClass<P>>
                    ): CFactory<P, ClassicComponent<P, any>>;
                    <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 forwardRef

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

                          function isValidElement

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

                            function lazy

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

                              function memo

                              memo: {
                              <P extends object>(
                              Component: FunctionComponent<P>,
                              propsAreEqual?: (
                              prevProps: Readonly<PropsWithChildren<P>>,
                              nextProps: Readonly<PropsWithChildren<P>>
                              ) => boolean
                              ): NamedExoticComponent<P>;
                              <T extends ComponentType<any>>(
                              Component: T,
                              propsAreEqual?: (
                              prevProps: Readonly<ComponentProps<T>>,
                              nextProps: Readonly<ComponentProps<T>>
                              ) => boolean
                              ): MemoExoticComponent<T>;
                              };

                                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_createMutableSource

                                unstable_createMutableSource: <T>(
                                source: T,
                                getVersion: () => any
                                ) => MutableSource<T>;
                                • Parameter source

                                  A source could be anything as long as they can be subscribed to and have a "version".

                                  Parameter getVersion

                                  A function returns a value which will change whenever part of the source changes.

                                function unstable_useMutableSource

                                unstable_useMutableSource: <T, TResult extends unknown>(
                                MutableSource: MutableSource<T>,
                                getSnapshot: (source: T) => TResult,
                                subscribe: MutableSourceSubscribe<T>
                                ) => TResult;
                                • useMutableSource() enables React components to safely and efficiently read from a mutable external source in Concurrent Mode. The API will detect mutations that occur during a render to avoid tearing and it will automatically schedule updates when the source is mutated.

                                  Parameter MutableSource

                                  Parameter getSnapshot

                                  Parameter subscribe

                                  See Also

                                  • https://github.com/reactjs/rfcs/blob/master/text/0147-use-mutable-source.md

                                function useCallback

                                useCallback: <T extends (...args: any[]) => any>(
                                callback: T,
                                deps: DependencyList
                                ) => T;
                                • useCallback will return a memoized version of the callback that only changes if one of the inputs has changed.

                                  16.8.0

                                  See Also

                                  • https://reactjs.org/docs/hooks-reference.html#usecallback

                                function useContext

                                useContext: <T>(context: Context<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

                                  • https://reactjs.org/docs/hooks-reference.html#usecontext

                                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

                                  • https://reactjs.org/docs/hooks-reference.html#usedebugvalue

                                function useDeferredValue

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

                                  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

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

                                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

                                  • https://reactjs.org/docs/hooks-reference.html#useeffect

                                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

                                    • https://reactjs.org/docs/hooks-reference.html#useimperativehandle

                                  function useInsertionEffect

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

                                    See Also

                                    • https://github.com/facebook/react/pull/21913

                                  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

                                    • https://reactjs.org/docs/hooks-reference.html#uselayouteffect

                                  function useMemo

                                  useMemo: <T>(factory: () => T, deps: DependencyList | undefined) => T;
                                  • useMemo will only recompute the memoized value when one of the deps has changed.

                                    Usage note: if calling useMemo with a referentially stable function, also give it as the input in the second argument.

                                    function expensive () { ... }
                                    function Component () {
                                    const expensiveResult = useMemo(expensive, [expensive])
                                    return ...
                                    }

                                    16.8.0

                                    See Also

                                    • https://reactjs.org/docs/hooks-reference.html#usememo

                                  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

                                    • https://reactjs.org/docs/hooks-reference.html#usereducer

                                  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

                                    • https://reactjs.org/docs/hooks-reference.html#useref

                                  • 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

                                    • https://reactjs.org/docs/hooks-reference.html#useref

                                  function useState

                                  useState: {
                                  <S>(initialState: S | (() => S)): [S, Dispatch<SetStateAction<S>>];
                                  <S = undefined>(): [S, Dispatch<SetStateAction<S>>];
                                  };
                                  • Returns a stateful value, and a function to update it.

                                    16.8.0

                                    See Also

                                    • https://reactjs.org/docs/hooks-reference.html#usestate

                                  function useSyncExternalStore

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

                                    Parameter getSnapshot

                                    See Also

                                    • https://github.com/reactwg/react-18/discussions/86

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

                                    Parameter config

                                    An optional object with timeoutMs

                                    See Also

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

                                  Classes

                                  class Component

                                  class Component<P, S> {}

                                    constructor

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

                                      constructor

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

                                        • https://reactjs.org/docs/legacy-context.html

                                        Deprecated

                                      property context

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

                                        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

                                        • https://reactjs.org/docs/context.html

                                      property contextType

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

                                        Usage:

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

                                        See Also

                                        • https://reactjs.org/docs/context.html#classcontexttype

                                      property props

                                      readonly props: Readonly<P> & Readonly<{ children?: ReactNode | undefined }>;

                                        property refs

                                        refs: { [key: string]: ReactInstance };
                                        • Deprecated

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

                                        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;

                                                                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 autoFocus

                                                                            autoFocus?: boolean | 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 content

                                                                                                    content?: string | undefined;

                                                                                                      property controls

                                                                                                      controls?: boolean | undefined;

                                                                                                        property coords

                                                                                                        coords?: string | undefined;

                                                                                                          property crossOrigin

                                                                                                          crossOrigin?: string | undefined;

                                                                                                            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;

                                                                                                                              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 nonce

                                                                                                                                                                                                nonce?: 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 rel

                                                                                                                                                                                                                    rel?: string | 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 | ReadonlyArray<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 rel

                                                                                                                                                                                                                                                                                            rel?: string | 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 rel

                                                                                                                                                                                                                                                                                                                          rel?: string | 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-busy'

                                                                                                                                                                                                                                                                                                                                  'aria-busy'?: Booleanish | undefined;
                                                                                                                                                                                                                                                                                                                                  • Indicates an element is being modified and that assistive technologies MAY want to wait until the modifications are complete before exposing them to the user.

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

                                                                                                                                                                                                                                                                                                                                                                                autoFocus?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                  property disabled

                                                                                                                                                                                                                                                                                                                                                                                  disabled?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                    property form

                                                                                                                                                                                                                                                                                                                                                                                    form?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                      property formAction

                                                                                                                                                                                                                                                                                                                                                                                      formAction?: string | 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 | ReadonlyArray<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 Attributes {}

                                                                                                                                                                                                                                                                                                                                                                                                                      property ref

                                                                                                                                                                                                                                                                                                                                                                                                                      ref?: LegacyRef<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                        interface ClassicComponent

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

                                                                                                                                                                                                                                                                                                                                                                                                                          method getInitialState

                                                                                                                                                                                                                                                                                                                                                                                                                          getInitialState: () => S;

                                                                                                                                                                                                                                                                                                                                                                                                                            method isMounted

                                                                                                                                                                                                                                                                                                                                                                                                                            isMounted: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                              method replaceState

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

                                                                                                                                                                                                                                                                                                                                                                                                                                interface ClassicComponentClass

                                                                                                                                                                                                                                                                                                                                                                                                                                interface ClassicComponentClass<P = {}> extends ComponentClass<P> {}

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property childContextTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                        childContextTypes?: ValidationMap<any> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          property contextType

                                                                                                                                                                                                                                                                                                                                                                                                                                                          contextType?: Context<any> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            property contextTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                            contextTypes?: ValidationMap<any> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              property defaultProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                              defaultProps?: Partial<P> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                property displayName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                displayName?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property propTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  propTypes?: WeakValidationMap<P> | undefined;

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

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property children

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        children: (value: T) => ReactNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface Context

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface Context<T> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property Consumer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Consumer: Consumer<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property displayName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              displayName?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                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 | ReadonlyArray<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;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Called immediately before mounting occurs, and before Component#render. Avoid introducing any side-effects or subscriptions in this method.

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  See Also

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#initializing-state

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#gradual-migration-path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Deprecated

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method componentWillReceiveProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                componentWillReceiveProps: (nextProps: Readonly<P>, nextContext: any) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Called when the component may be receiving new props. React may call this even if props have not changed, so be sure to compare new and existing props if you only want to handle changes.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Calling Component#setState generally does not trigger this method.

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  See Also

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#updating-state-based-on-props

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#gradual-migration-path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Deprecated

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method componentWillUpdate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                componentWillUpdate: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                nextProps: Readonly<P>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                nextState: Readonly<S>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                nextContext: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Called immediately before rendering when new props or state is received. Not called for the initial render.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Note: You cannot call Component#setState here.

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  See Also

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#reading-dom-properties-before-an-update

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#gradual-migration-path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Deprecated

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method UNSAFE_componentWillMount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                UNSAFE_componentWillMount: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Called immediately before mounting occurs, and before Component#render. Avoid introducing any side-effects or subscriptions in this method.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  This method will not stop working in React 17.

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  See Also

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#initializing-state

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#gradual-migration-path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  16.3, use componentDidMount or the constructor instead

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method UNSAFE_componentWillReceiveProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                UNSAFE_componentWillReceiveProps: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                nextProps: Readonly<P>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                nextContext: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Called when the component may be receiving new props. React may call this even if props have not changed, so be sure to compare new and existing props if you only want to handle changes.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Calling Component#setState generally does not trigger this method.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  This method will not stop working in React 17.

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  See Also

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#updating-state-based-on-props

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#gradual-migration-path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  16.3, use static getDerivedStateFromProps instead

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method UNSAFE_componentWillUpdate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                UNSAFE_componentWillUpdate: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                nextProps: Readonly<P>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                nextState: Readonly<S>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                nextContext: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Called immediately before rendering when new props or state is received. Not called for the initial render.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Note: You cannot call Component#setState here.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  This method will not stop working in React 17.

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  See Also

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#reading-dom-properties-before-an-update

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#gradual-migration-path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  16.3, use getSnapshotBeforeUpdate instead

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                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 onToggle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          onToggle?: ReactEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property open

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            open?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface DialogHTMLAttributes

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                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 DOMAttributes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface DOMAttributes<T> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property children

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      children?: ReactNode | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property dangerouslySetInnerHTML

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        dangerouslySetInnerHTML?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        __html: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onCopyCapture?: ClipboardEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property onCut

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          onCut?: ClipboardEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property onCutCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onCutCapture?: ClipboardEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property onDoubleClick

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              onDoubleClick?: MouseEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property onDoubleClickCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onDoubleClickCapture?: MouseEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property onDrag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  onDrag?: DragEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property onDragCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onDragCapture?: DragEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property onDragEnd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onDragEnd?: DragEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onDragEndCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onDragEndCapture?: DragEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property onDragEnter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          onDragEnter?: DragEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property onDragEnterCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onDragEnterCapture?: DragEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property onDragExit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              onDragExit?: DragEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property onDragExitCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onDragExitCapture?: DragEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property onDragLeave

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  onDragLeave?: DragEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property onDragLeaveCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onDragLeaveCapture?: DragEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property onDragOver

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onDragOver?: DragEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onDragOverCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onDragOverCapture?: DragEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property onDragStart

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          onDragStart?: DragEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property onDragStartCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onDragStartCapture?: DragEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property onDrop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              onDrop?: DragEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property onDropCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onDropCapture?: DragEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property onDurationChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  onDurationChange?: ReactEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property onDurationChangeCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onDurationChangeCapture?: ReactEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property onEmptied

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onEmptied?: ReactEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onEmptiedCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onEmptiedCapture?: ReactEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property onEncrypted

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          onEncrypted?: ReactEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property onEncryptedCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onEncryptedCapture?: ReactEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property onEnded

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              onEnded?: ReactEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property onEndedCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onEndedCapture?: ReactEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property onError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  onError?: ReactEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property onErrorCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onErrorCapture?: ReactEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property onFocus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onFocus?: FocusEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onFocusCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onFocusCapture?: FocusEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property onGotPointerCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          onGotPointerCapture?: PointerEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property onGotPointerCaptureCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onGotPointerCaptureCapture?: PointerEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property onInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              onInput?: FormEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property onInputCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onInputCapture?: FormEventHandler<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property onInvalid