@types/react

  • Version 17.0.11
  • Published
  • 165 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 }>;

      variable opaqueIdentifierBranding

      const opaqueIdentifierBranding: Symbol;

        variable Profiler

        const Profiler: ExoticComponent<ProfilerProps>;

          variable StrictMode

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

            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: SFC<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 unstable_useOpaqueIdentifier

                                  unstable_useOpaqueIdentifier: () => OpaqueIdentifier;

                                    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 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 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 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 boolean, React’s way of informing us whether we’re waiting for the transition to finish. The seconda 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 }>;

                                          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;

                                                              property acceptCharset

                                                              acceptCharset?: string;

                                                                property action

                                                                action?: string;

                                                                  property allowFullScreen

                                                                  allowFullScreen?: boolean;

                                                                    property allowTransparency

                                                                    allowTransparency?: boolean;

                                                                      property alt

                                                                      alt?: string;

                                                                        property as

                                                                        as?: string;

                                                                          property async

                                                                          async?: boolean;

                                                                            property autoComplete

                                                                            autoComplete?: string;

                                                                              property autoFocus

                                                                              autoFocus?: boolean;

                                                                                property autoPlay

                                                                                autoPlay?: boolean;

                                                                                  property capture

                                                                                  capture?: boolean | string;

                                                                                    property cellPadding

                                                                                    cellPadding?: number | string;

                                                                                      property cellSpacing

                                                                                      cellSpacing?: number | string;

                                                                                        property challenge

                                                                                        challenge?: string;

                                                                                          property charSet

                                                                                          charSet?: string;

                                                                                            property checked

                                                                                            checked?: boolean;

                                                                                              property cite

                                                                                              cite?: string;

                                                                                                property classID

                                                                                                classID?: string;

                                                                                                  property cols

                                                                                                  cols?: number;

                                                                                                    property colSpan

                                                                                                    colSpan?: number;

                                                                                                      property content

                                                                                                      content?: string;

                                                                                                        property controls

                                                                                                        controls?: boolean;

                                                                                                          property coords

                                                                                                          coords?: string;

                                                                                                            property crossOrigin

                                                                                                            crossOrigin?: string;

                                                                                                              property data

                                                                                                              data?: string;

                                                                                                                property dateTime

                                                                                                                dateTime?: string;

                                                                                                                  property default

                                                                                                                  default?: boolean;

                                                                                                                    property defer

                                                                                                                    defer?: boolean;

                                                                                                                      property disabled

                                                                                                                      disabled?: boolean;

                                                                                                                        property download

                                                                                                                        download?: any;

                                                                                                                          property encType

                                                                                                                          encType?: string;

                                                                                                                            property form

                                                                                                                            form?: string;

                                                                                                                              property formAction

                                                                                                                              formAction?: string;

                                                                                                                                property formEncType

                                                                                                                                formEncType?: string;

                                                                                                                                  property formMethod

                                                                                                                                  formMethod?: string;

                                                                                                                                    property formNoValidate

                                                                                                                                    formNoValidate?: boolean;

                                                                                                                                      property formTarget

                                                                                                                                      formTarget?: string;

                                                                                                                                        property frameBorder

                                                                                                                                        frameBorder?: number | string;

                                                                                                                                          property headers

                                                                                                                                          headers?: string;

                                                                                                                                            property height

                                                                                                                                            height?: number | string;

                                                                                                                                              property high

                                                                                                                                              high?: number;

                                                                                                                                                property href

                                                                                                                                                href?: string;

                                                                                                                                                  property hrefLang

                                                                                                                                                  hrefLang?: string;

                                                                                                                                                    property htmlFor

                                                                                                                                                    htmlFor?: string;

                                                                                                                                                      property httpEquiv

                                                                                                                                                      httpEquiv?: string;

                                                                                                                                                        property integrity

                                                                                                                                                        integrity?: string;

                                                                                                                                                          property keyParams

                                                                                                                                                          keyParams?: string;

                                                                                                                                                            property keyType

                                                                                                                                                            keyType?: string;

                                                                                                                                                              property kind

                                                                                                                                                              kind?: string;

                                                                                                                                                                property label

                                                                                                                                                                label?: string;

                                                                                                                                                                  property list

                                                                                                                                                                  list?: string;

                                                                                                                                                                    property loop

                                                                                                                                                                    loop?: boolean;

                                                                                                                                                                      property low

                                                                                                                                                                      low?: number;

                                                                                                                                                                        property manifest

                                                                                                                                                                        manifest?: string;

                                                                                                                                                                          property marginHeight

                                                                                                                                                                          marginHeight?: number;

                                                                                                                                                                            property marginWidth

                                                                                                                                                                            marginWidth?: number;

                                                                                                                                                                              property max

                                                                                                                                                                              max?: number | string;

                                                                                                                                                                                property maxLength

                                                                                                                                                                                maxLength?: number;

                                                                                                                                                                                  property media

                                                                                                                                                                                  media?: string;

                                                                                                                                                                                    property mediaGroup

                                                                                                                                                                                    mediaGroup?: string;

                                                                                                                                                                                      property method

                                                                                                                                                                                      method?: string;

                                                                                                                                                                                        property min

                                                                                                                                                                                        min?: number | string;

                                                                                                                                                                                          property minLength

                                                                                                                                                                                          minLength?: number;

                                                                                                                                                                                            property multiple

                                                                                                                                                                                            multiple?: boolean;

                                                                                                                                                                                              property muted

                                                                                                                                                                                              muted?: boolean;

                                                                                                                                                                                                property name

                                                                                                                                                                                                name?: string;

                                                                                                                                                                                                  property nonce

                                                                                                                                                                                                  nonce?: string;

                                                                                                                                                                                                    property noValidate

                                                                                                                                                                                                    noValidate?: boolean;

                                                                                                                                                                                                      property open

                                                                                                                                                                                                      open?: boolean;

                                                                                                                                                                                                        property optimum

                                                                                                                                                                                                        optimum?: number;

                                                                                                                                                                                                          property pattern

                                                                                                                                                                                                          pattern?: string;

                                                                                                                                                                                                            property placeholder

                                                                                                                                                                                                            placeholder?: string;

                                                                                                                                                                                                              property playsInline

                                                                                                                                                                                                              playsInline?: boolean;

                                                                                                                                                                                                                property poster

                                                                                                                                                                                                                poster?: string;

                                                                                                                                                                                                                  property preload

                                                                                                                                                                                                                  preload?: string;

                                                                                                                                                                                                                    property readOnly

                                                                                                                                                                                                                    readOnly?: boolean;

                                                                                                                                                                                                                      property rel

                                                                                                                                                                                                                      rel?: string;

                                                                                                                                                                                                                        property required

                                                                                                                                                                                                                        required?: boolean;

                                                                                                                                                                                                                          property reversed

                                                                                                                                                                                                                          reversed?: boolean;

                                                                                                                                                                                                                            property rows

                                                                                                                                                                                                                            rows?: number;

                                                                                                                                                                                                                              property rowSpan

                                                                                                                                                                                                                              rowSpan?: number;

                                                                                                                                                                                                                                property sandbox

                                                                                                                                                                                                                                sandbox?: string;

                                                                                                                                                                                                                                  property scope

                                                                                                                                                                                                                                  scope?: string;

                                                                                                                                                                                                                                    property scoped

                                                                                                                                                                                                                                    scoped?: boolean;

                                                                                                                                                                                                                                      property scrolling

                                                                                                                                                                                                                                      scrolling?: string;

                                                                                                                                                                                                                                        property seamless

                                                                                                                                                                                                                                        seamless?: boolean;

                                                                                                                                                                                                                                          property selected

                                                                                                                                                                                                                                          selected?: boolean;

                                                                                                                                                                                                                                            property shape

                                                                                                                                                                                                                                            shape?: string;

                                                                                                                                                                                                                                              property size

                                                                                                                                                                                                                                              size?: number;

                                                                                                                                                                                                                                                property sizes

                                                                                                                                                                                                                                                sizes?: string;

                                                                                                                                                                                                                                                  property span

                                                                                                                                                                                                                                                  span?: number;

                                                                                                                                                                                                                                                    property src

                                                                                                                                                                                                                                                    src?: string;

                                                                                                                                                                                                                                                      property srcDoc

                                                                                                                                                                                                                                                      srcDoc?: string;

                                                                                                                                                                                                                                                        property srcLang

                                                                                                                                                                                                                                                        srcLang?: string;

                                                                                                                                                                                                                                                          property srcSet

                                                                                                                                                                                                                                                          srcSet?: string;

                                                                                                                                                                                                                                                            property start

                                                                                                                                                                                                                                                            start?: number;

                                                                                                                                                                                                                                                              property step

                                                                                                                                                                                                                                                              step?: number | string;

                                                                                                                                                                                                                                                                property summary

                                                                                                                                                                                                                                                                summary?: string;

                                                                                                                                                                                                                                                                  property target

                                                                                                                                                                                                                                                                  target?: string;

                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                    type?: string;

                                                                                                                                                                                                                                                                      property useMap

                                                                                                                                                                                                                                                                      useMap?: string;

                                                                                                                                                                                                                                                                        property value

                                                                                                                                                                                                                                                                        value?: string | ReadonlyArray<string> | number;

                                                                                                                                                                                                                                                                          property width

                                                                                                                                                                                                                                                                          width?: number | string;

                                                                                                                                                                                                                                                                            property wmode

                                                                                                                                                                                                                                                                            wmode?: string;

                                                                                                                                                                                                                                                                              property wrap

                                                                                                                                                                                                                                                                              wrap?: string;

                                                                                                                                                                                                                                                                                interface AnchorHTMLAttributes

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

                                                                                                                                                                                                                                                                                  property download

                                                                                                                                                                                                                                                                                  download?: any;

                                                                                                                                                                                                                                                                                    property href

                                                                                                                                                                                                                                                                                    href?: string;

                                                                                                                                                                                                                                                                                      property hrefLang

                                                                                                                                                                                                                                                                                      hrefLang?: string;

                                                                                                                                                                                                                                                                                        property media

                                                                                                                                                                                                                                                                                        media?: string;

                                                                                                                                                                                                                                                                                          property ping

                                                                                                                                                                                                                                                                                          ping?: string;

                                                                                                                                                                                                                                                                                            property referrerPolicy

                                                                                                                                                                                                                                                                                            referrerPolicy?: HTMLAttributeReferrerPolicy;

                                                                                                                                                                                                                                                                                              property rel

                                                                                                                                                                                                                                                                                              rel?: string;

                                                                                                                                                                                                                                                                                                property target

                                                                                                                                                                                                                                                                                                target?: string;

                                                                                                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                                                                                                  type?: string;

                                                                                                                                                                                                                                                                                                    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;

                                                                                                                                                                                                                                                                                                                property coords

                                                                                                                                                                                                                                                                                                                coords?: string;

                                                                                                                                                                                                                                                                                                                  property download

                                                                                                                                                                                                                                                                                                                  download?: any;

                                                                                                                                                                                                                                                                                                                    property href

                                                                                                                                                                                                                                                                                                                    href?: string;

                                                                                                                                                                                                                                                                                                                      property hrefLang

                                                                                                                                                                                                                                                                                                                      hrefLang?: string;

                                                                                                                                                                                                                                                                                                                        property media

                                                                                                                                                                                                                                                                                                                        media?: string;

                                                                                                                                                                                                                                                                                                                          property referrerPolicy

                                                                                                                                                                                                                                                                                                                          referrerPolicy?: HTMLAttributeReferrerPolicy;

                                                                                                                                                                                                                                                                                                                            property rel

                                                                                                                                                                                                                                                                                                                            rel?: string;

                                                                                                                                                                                                                                                                                                                              property shape

                                                                                                                                                                                                                                                                                                                              shape?: string;

                                                                                                                                                                                                                                                                                                                                property target

                                                                                                                                                                                                                                                                                                                                target?: string;

                                                                                                                                                                                                                                                                                                                                  interface AriaAttributes

                                                                                                                                                                                                                                                                                                                                  interface AriaAttributes {}

                                                                                                                                                                                                                                                                                                                                    property 'aria-activedescendant'

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

                                                                                                                                                                                                                                                                                                                                    property 'aria-atomic'

                                                                                                                                                                                                                                                                                                                                    'aria-atomic'?: boolean | 'false' | 'true';
                                                                                                                                                                                                                                                                                                                                    • 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';
                                                                                                                                                                                                                                                                                                                                    • 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'?: boolean | 'false' | 'true';
                                                                                                                                                                                                                                                                                                                                    • 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';
                                                                                                                                                                                                                                                                                                                                    • Indicates the current "checked" state of checkboxes, radio buttons, and other widgets.

                                                                                                                                                                                                                                                                                                                                      See Also

                                                                                                                                                                                                                                                                                                                                      • aria-pressed

                                                                                                                                                                                                                                                                                                                                      • aria-selected.

                                                                                                                                                                                                                                                                                                                                    property 'aria-colcount'

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

                                                                                                                                                                                                                                                                                                                                      See Also

                                                                                                                                                                                                                                                                                                                                      • aria-colindex.

                                                                                                                                                                                                                                                                                                                                    property 'aria-colindex'

                                                                                                                                                                                                                                                                                                                                    'aria-colindex'?: number;
                                                                                                                                                                                                                                                                                                                                    • 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;
                                                                                                                                                                                                                                                                                                                                    • 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;
                                                                                                                                                                                                                                                                                                                                    • 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';
                                                                                                                                                                                                                                                                                                                                    • Indicates the element that represents the current item within a container or set of related elements.

                                                                                                                                                                                                                                                                                                                                    property 'aria-describedby'

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

                                                                                                                                                                                                                                                                                                                                      See Also

                                                                                                                                                                                                                                                                                                                                      • aria-labelledby

                                                                                                                                                                                                                                                                                                                                    property 'aria-details'

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

                                                                                                                                                                                                                                                                                                                                      See Also

                                                                                                                                                                                                                                                                                                                                      • aria-describedby.

                                                                                                                                                                                                                                                                                                                                    property 'aria-disabled'

                                                                                                                                                                                                                                                                                                                                    'aria-disabled'?: boolean | 'false' | 'true';
                                                                                                                                                                                                                                                                                                                                    • 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';
                                                                                                                                                                                                                                                                                                                                    • 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;
                                                                                                                                                                                                                                                                                                                                    • Identifies the element that provides an error message for the object.

                                                                                                                                                                                                                                                                                                                                      See Also

                                                                                                                                                                                                                                                                                                                                      • aria-invalid

                                                                                                                                                                                                                                                                                                                                      • aria-describedby.

                                                                                                                                                                                                                                                                                                                                    property 'aria-expanded'

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

                                                                                                                                                                                                                                                                                                                                    property 'aria-flowto'

                                                                                                                                                                                                                                                                                                                                    'aria-flowto'?: string;
                                                                                                                                                                                                                                                                                                                                    • 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'?: boolean | 'false' | 'true';
                                                                                                                                                                                                                                                                                                                                    • 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';
                                                                                                                                                                                                                                                                                                                                    • 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'?: boolean | 'false' | 'true';
                                                                                                                                                                                                                                                                                                                                    • Indicates whether the element is exposed to an accessibility API.

                                                                                                                                                                                                                                                                                                                                      See Also

                                                                                                                                                                                                                                                                                                                                      • aria-disabled.

                                                                                                                                                                                                                                                                                                                                    property 'aria-invalid'

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

                                                                                                                                                                                                                                                                                                                                      See Also

                                                                                                                                                                                                                                                                                                                                      • aria-errormessage.

                                                                                                                                                                                                                                                                                                                                    property 'aria-keyshortcuts'

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

                                                                                                                                                                                                                                                                                                                                    property 'aria-label'

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

                                                                                                                                                                                                                                                                                                                                      See Also

                                                                                                                                                                                                                                                                                                                                      • aria-labelledby.

                                                                                                                                                                                                                                                                                                                                    property 'aria-labelledby'

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

                                                                                                                                                                                                                                                                                                                                      See Also

                                                                                                                                                                                                                                                                                                                                      • aria-describedby.

                                                                                                                                                                                                                                                                                                                                    property 'aria-level'

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

                                                                                                                                                                                                                                                                                                                                    property 'aria-live'

                                                                                                                                                                                                                                                                                                                                    'aria-live'?: 'off' | 'assertive' | 'polite';
                                                                                                                                                                                                                                                                                                                                    • 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'?: boolean | 'false' | 'true';
                                                                                                                                                                                                                                                                                                                                    • Indicates whether an element is modal when displayed.

                                                                                                                                                                                                                                                                                                                                    property 'aria-multiline'

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

                                                                                                                                                                                                                                                                                                                                    property 'aria-multiselectable'

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

                                                                                                                                                                                                                                                                                                                                    property 'aria-orientation'

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

                                                                                                                                                                                                                                                                                                                                    property 'aria-owns'

                                                                                                                                                                                                                                                                                                                                    'aria-owns'?: string;
                                                                                                                                                                                                                                                                                                                                    • 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;
                                                                                                                                                                                                                                                                                                                                    • 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;
                                                                                                                                                                                                                                                                                                                                    • 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';
                                                                                                                                                                                                                                                                                                                                    • Indicates the current "pressed" state of toggle buttons.

                                                                                                                                                                                                                                                                                                                                      See Also

                                                                                                                                                                                                                                                                                                                                      • aria-checked

                                                                                                                                                                                                                                                                                                                                      • aria-selected.

                                                                                                                                                                                                                                                                                                                                    property 'aria-readonly'

                                                                                                                                                                                                                                                                                                                                    'aria-readonly'?: boolean | 'false' | 'true';
                                                                                                                                                                                                                                                                                                                                    • 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';
                                                                                                                                                                                                                                                                                                                                    • 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'?: boolean | 'false' | 'true';
                                                                                                                                                                                                                                                                                                                                    • Indicates that user input is required on the element before a form may be submitted.

                                                                                                                                                                                                                                                                                                                                    property 'aria-roledescription'

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

                                                                                                                                                                                                                                                                                                                                    property 'aria-rowcount'

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

                                                                                                                                                                                                                                                                                                                                      See Also

                                                                                                                                                                                                                                                                                                                                      • aria-rowindex.

                                                                                                                                                                                                                                                                                                                                    property 'aria-rowindex'

                                                                                                                                                                                                                                                                                                                                    'aria-rowindex'?: number;
                                                                                                                                                                                                                                                                                                                                    • 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;
                                                                                                                                                                                                                                                                                                                                    • 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'?: boolean | 'false' | 'true';
                                                                                                                                                                                                                                                                                                                                    • Indicates the current "selected" state of various widgets.

                                                                                                                                                                                                                                                                                                                                      See Also

                                                                                                                                                                                                                                                                                                                                      • aria-checked

                                                                                                                                                                                                                                                                                                                                      • aria-pressed.

                                                                                                                                                                                                                                                                                                                                    property 'aria-setsize'

                                                                                                                                                                                                                                                                                                                                    'aria-setsize'?: number;
                                                                                                                                                                                                                                                                                                                                    • 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';
                                                                                                                                                                                                                                                                                                                                    • Indicates if items in a table or grid are sorted in ascending or descending order.

                                                                                                                                                                                                                                                                                                                                    property 'aria-valuemax'

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

                                                                                                                                                                                                                                                                                                                                    property 'aria-valuemin'

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

                                                                                                                                                                                                                                                                                                                                    property 'aria-valuenow'

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

                                                                                                                                                                                                                                                                                                                                      See Also

                                                                                                                                                                                                                                                                                                                                      • aria-valuetext.

                                                                                                                                                                                                                                                                                                                                    property 'aria-valuetext'

                                                                                                                                                                                                                                                                                                                                    'aria-valuetext'?: string;
                                                                                                                                                                                                                                                                                                                                    • 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;

                                                                                                                                                                                                                                                                                                                                          property target

                                                                                                                                                                                                                                                                                                                                          target?: string;

                                                                                                                                                                                                                                                                                                                                            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;

                                                                                                                                                                                                                                                                                                                                                                                interface ButtonHTMLAttributes

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

                                                                                                                                                                                                                                                                                                                                                                                  property autoFocus

                                                                                                                                                                                                                                                                                                                                                                                  autoFocus?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                    property disabled

                                                                                                                                                                                                                                                                                                                                                                                    disabled?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                      property form

                                                                                                                                                                                                                                                                                                                                                                                      form?: string;

                                                                                                                                                                                                                                                                                                                                                                                        property formAction

                                                                                                                                                                                                                                                                                                                                                                                        formAction?: string;

                                                                                                                                                                                                                                                                                                                                                                                          property formEncType

                                                                                                                                                                                                                                                                                                                                                                                          formEncType?: string;

                                                                                                                                                                                                                                                                                                                                                                                            property formMethod

                                                                                                                                                                                                                                                                                                                                                                                            formMethod?: string;

                                                                                                                                                                                                                                                                                                                                                                                              property formNoValidate

                                                                                                                                                                                                                                                                                                                                                                                              formNoValidate?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                property formTarget

                                                                                                                                                                                                                                                                                                                                                                                                formTarget?: string;

                                                                                                                                                                                                                                                                                                                                                                                                  property name

                                                                                                                                                                                                                                                                                                                                                                                                  name?: string;

                                                                                                                                                                                                                                                                                                                                                                                                    property type

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

                                                                                                                                                                                                                                                                                                                                                                                                      property value

                                                                                                                                                                                                                                                                                                                                                                                                      value?: string | ReadonlyArray<string> | number;

                                                                                                                                                                                                                                                                                                                                                                                                        interface CanvasHTMLAttributes

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

                                                                                                                                                                                                                                                                                                                                                                                                          property height

                                                                                                                                                                                                                                                                                                                                                                                                          height?: number | string;

                                                                                                                                                                                                                                                                                                                                                                                                            property width

                                                                                                                                                                                                                                                                                                                                                                                                            width?: number | string;

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

                                                                                                                                                                                                                                                                                                                                                                                                                          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;

                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ColHTMLAttributes

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                  property span

                                                                                                                                                                                                                                                                                                                                                                                                                                                  span?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    property width

                                                                                                                                                                                                                                                                                                                                                                                                                                                    width?: number | string;

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                            property contextType

                                                                                                                                                                                                                                                                                                                                                                                                                                                            contextType?: Context<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              property contextTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                              contextTypes?: ValidationMap<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                property defaultProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                defaultProps?: Partial<P>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property displayName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  displayName?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property propTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    propTypes?: WeakValidationMap<P>;

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            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;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  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;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface DelHTMLAttributes

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property cite

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            cite?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property dateTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              dateTime?: string;

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property open

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              open?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface DialogHTMLAttributes

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property open

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  open?: boolean;

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property dangerouslySetInnerHTML

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          dangerouslySetInnerHTML?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          __html: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property onAbort

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onAbort?: ReactEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property onAbortCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              onAbortCapture?: ReactEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property onAnimationEnd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onAnimationEnd?: AnimationEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property onAnimationEndCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  onAnimationEndCapture?: AnimationEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property onAnimationIteration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onAnimationIteration?: AnimationEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property onAnimationIterationCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onAnimationIterationCapture?: AnimationEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onAnimationStart

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onAnimationStart?: AnimationEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property onAnimationStartCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          onAnimationStartCapture?: AnimationEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property onAuxClick

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onAuxClick?: MouseEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property onAuxClickCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              onAuxClickCapture?: MouseEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property onBeforeInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onBeforeInput?: FormEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property onBeforeInputCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  onBeforeInputCapture?: FormEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property onBlur

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onBlur?: FocusEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property onBlurCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onBlurCapture?: FocusEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onCanPlay

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onCanPlay?: ReactEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property onCanPlayCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          onCanPlayCapture?: ReactEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property onCanPlayThrough

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onCanPlayThrough?: ReactEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property onCanPlayThroughCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              onCanPlayThroughCapture?: ReactEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property onChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onChange?: FormEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property onChangeCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  onChangeCapture?: FormEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property onClick

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onClick?: MouseEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property onClickCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onClickCapture?: MouseEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onCompositionEnd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onCompositionEnd?: CompositionEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property onCompositionEndCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          onCompositionEndCapture?: CompositionEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property onCompositionStart

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onCompositionStart?: CompositionEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property onCompositionStartCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              onCompositionStartCapture?: CompositionEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property onCompositionUpdate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onCompositionUpdate?: CompositionEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property onCompositionUpdateCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  onCompositionUpdateCapture?: CompositionEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property onContextMenu

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onContextMenu?: MouseEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property onContextMenuCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onContextMenuCapture?: MouseEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onCopy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onCopy?: ClipboardEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property onCopyCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          onCopyCapture?: ClipboardEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property onCut

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onCut?: ClipboardEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property onCutCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              onCutCapture?: ClipboardEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property onDoubleClick

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onDoubleClick?: MouseEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property onDoubleClickCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  onDoubleClickCapture?: MouseEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property onDrag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onDrag?: DragEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property onDragCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onDragCapture?: DragEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onDragEnd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onDragEnd?: DragEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property onDragEndCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          onDragEndCapture?: DragEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property onDragEnter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onDragEnter?: DragEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property onDragEnterCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              onDragEnterCapture?: DragEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property onDragExit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onDragExit?: DragEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property onDragExitCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  onDragExitCapture?: DragEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property onDragLeave

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onDragLeave?: DragEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property onDragLeaveCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onDragLeaveCapture?: DragEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onDragOver

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onDragOver?: DragEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property onDragOverCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          onDragOverCapture?: DragEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property onDragStart

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onDragStart?: DragEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property onDragStartCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              onDragStartCapture?: DragEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property onDrop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onDrop?: DragEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property onDropCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  onDropCapture?: DragEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property onDurationChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onDurationChange?: ReactEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property onDurationChangeCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onDurationChangeCapture?: ReactEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onEmptied

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onEmptied?: ReactEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property onEmptiedCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          onEmptiedCapture?: ReactEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property onEncrypted

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onEncrypted?: ReactEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property onEncryptedCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              onEncryptedCapture?: ReactEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property onEnded

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onEnded?: ReactEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property onEndedCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  onEndedCapture?: ReactEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property onError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onError?: ReactEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property onErrorCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onErrorCapture?: ReactEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onFocus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onFocus?: FocusEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property onFocusCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          onFocusCapture?: FocusEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property onGotPointerCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onGotPointerCapture?: PointerEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property onGotPointerCaptureCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              onGotPointerCaptureCapture?: PointerEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property onInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onInput?: FormEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property onInputCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  onInputCapture?: FormEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property onInvalid

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onInvalid?: FormEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property onInvalidCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onInvalidCapture?: FormEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onKeyDown

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onKeyDown?: KeyboardEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property onKeyDownCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          onKeyDownCapture?: KeyboardEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property onKeyPress

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onKeyPress?: KeyboardEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property onKeyPressCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              onKeyPressCapture?: KeyboardEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property onKeyUp

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onKeyUp?: KeyboardEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property onKeyUpCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  onKeyUpCapture?: KeyboardEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property onLoad

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onLoad?: ReactEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property onLoadCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onLoadCapture?: ReactEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onLoadedData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onLoadedData?: ReactEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property onLoadedDataCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          onLoadedDataCapture?: ReactEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property onLoadedMetadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onLoadedMetadata?: ReactEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property onLoadedMetadataCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              onLoadedMetadataCapture?: ReactEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property onLoadStart

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onLoadStart?: ReactEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property onLoadStartCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  onLoadStartCapture?: ReactEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property onLostPointerCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onLostPointerCapture?: PointerEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property onLostPointerCaptureCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onLostPointerCaptureCapture?: PointerEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onMouseDown

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onMouseDown?: MouseEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property onMouseDownCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          onMouseDownCapture?: MouseEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property onMouseEnter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onMouseEnter?: MouseEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property onMouseLeave

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              onMouseLeave?: MouseEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property onMouseMove

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onMouseMove?: MouseEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property onMouseMoveCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  onMouseMoveCapture?: MouseEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property onMouseOut

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onMouseOut?: MouseEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property onMouseOutCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onMouseOutCapture?: MouseEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onMouseOver

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onMouseOver?: MouseEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property onMouseOverCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          onMouseOverCapture?: MouseEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property onMouseUp

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onMouseUp?: MouseEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property onMouseUpCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              onMouseUpCapture?: MouseEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property onPaste

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onPaste?: ClipboardEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property onPasteCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  onPasteCapture?: ClipboardEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property onPause

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onPause?: ReactEventHandler<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property onPauseCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onPauseCapture?: ReactEventHandler<T>;