;\n }\n\n interface ReactElement {\n type: string | ComponentClass
| FunctionComponent
;\n props: P;\n key: Key | null;\n }\n\n /**\n * @deprecated Please use `FunctionComponentElement`\n */\n type SFCElement
= FunctionComponentElement
;\n\n interface FunctionComponentElement
extends ReactElement
{\n type: FunctionComponent
;\n ref?: 'ref' extends keyof P ? P extends { ref?: infer R } ? R : never : never;\n }\n\n type CElement> = ComponentElement;\n interface ComponentElement> extends ReactElement {\n type: ComponentClass
;\n ref?: LegacyRef;\n }\n\n type ClassicElement = CElement>;\n\n // string fallback for custom web-components\n interface DOMElement | SVGAttributes, T extends Element> extends ReactElement {\n type: string;\n ref: LegacyRef;\n }\n\n // ReactHTML for ReactHTMLElement\n // tslint:disable-next-line:no-empty-interface\n interface ReactHTMLElement extends DetailedReactHTMLElement, T> { }\n\n interface DetailedReactHTMLElement, T extends HTMLElement> extends DOMElement {\n type: keyof ReactHTML;\n }\n\n // ReactSVG for ReactSVGElement\n interface ReactSVGElement extends DOMElement, SVGElement> {\n type: keyof ReactSVG;\n }\n\n interface ReactPortal extends ReactElement {\n key: Key | null;\n children: ReactNode;\n }\n\n //\n // Factories\n // ----------------------------------------------------------------------\n\n type Factory = (props?: Attributes & P, ...children: ReactNode[]) => ReactElement
;\n\n /**\n * @deprecated Please use `FunctionComponentFactory`\n */\n type SFCFactory
= FunctionComponentFactory
;\n\n type FunctionComponentFactory
= (props?: Attributes & P, ...children: ReactNode[]) => FunctionComponentElement
;\n\n type ComponentFactory> =\n (props?: ClassAttributes & P, ...children: ReactNode[]) => CElement;\n\n type CFactory> = ComponentFactory;\n type ClassicFactory = CFactory>;\n\n type DOMFactory, T extends Element> =\n (props?: ClassAttributes & P | null, ...children: ReactNode[]) => DOMElement;\n\n // tslint:disable-next-line:no-empty-interface\n interface HTMLFactory extends DetailedHTMLFactory, T> {}\n\n interface DetailedHTMLFactory, T extends HTMLElement> extends DOMFactory {\n (props?: ClassAttributes & P | null, ...children: ReactNode[]): DetailedReactHTMLElement;\n }\n\n interface SVGFactory extends DOMFactory, SVGElement> {\n (props?: ClassAttributes & SVGAttributes | null, ...children: ReactNode[]): ReactSVGElement;\n }\n\n //\n // React Nodes\n // http://facebook.github.io/react/docs/glossary.html\n // ----------------------------------------------------------------------\n\n type ReactText = string | number;\n type ReactChild = ReactElement | ReactText;\n\n interface ReactNodeArray extends Array {}\n type ReactFragment = {} | ReactNodeArray;\n type ReactNode = ReactChild | ReactFragment | ReactPortal | boolean | null | undefined;\n\n //\n // Top Level API\n // ----------------------------------------------------------------------\n\n // DOM Elements\n function createFactory(\n type: keyof ReactHTML): HTMLFactory;\n function createFactory(\n type: keyof ReactSVG): SVGFactory;\n function createFactory, T extends Element>(\n type: string): DOMFactory;\n\n // Custom components\n function createFactory(type: FunctionComponent
): FunctionComponentFactory
;\n function createFactory
(\n type: ClassType, ClassicComponentClass>): CFactory>;\n function createFactory, C extends ComponentClass>(\n type: ClassType): CFactory;\n function createFactory(type: ComponentClass
): Factory
;\n\n // DOM Elements\n // TODO: generalize this to everything in `keyof ReactHTML`, not just \"input\"\n function createElement(\n type: \"input\",\n props?: InputHTMLAttributes & ClassAttributes | null,\n ...children: ReactNode[]): DetailedReactHTMLElement, HTMLInputElement>;\n function createElement, T extends HTMLElement>(\n type: keyof ReactHTML,\n props?: ClassAttributes & P | null,\n ...children: ReactNode[]): DetailedReactHTMLElement;\n function createElement, T extends SVGElement>(\n type: keyof ReactSVG,\n props?: ClassAttributes & P | null,\n ...children: ReactNode[]): ReactSVGElement;\n function createElement, T extends Element>(\n type: string,\n props?: ClassAttributes & P | null,\n ...children: ReactNode[]): DOMElement;\n\n // Custom components\n\n function createElement(\n type: FunctionComponent
,\n props?: Attributes & P | null,\n ...children: ReactNode[]): FunctionComponentElement
;\n function createElement
(\n type: ClassType, ClassicComponentClass>,\n props?: ClassAttributes> & P | null,\n ...children: ReactNode[]): CElement>;\n function createElement, C extends ComponentClass
>(\n type: ClassType,\n props?: ClassAttributes & P | null,\n ...children: ReactNode[]): CElement;\n function createElement(\n type: FunctionComponent
| ComponentClass
| string,\n props?: Attributes & P | null,\n ...children: ReactNode[]): ReactElement
;\n\n // DOM Elements\n // ReactHTMLElement\n function cloneElement
, T extends HTMLElement>(\n element: DetailedReactHTMLElement,\n props?: P,\n ...children: ReactNode[]): DetailedReactHTMLElement;\n // ReactHTMLElement, less specific\n function cloneElement, T extends HTMLElement>(\n element: ReactHTMLElement,\n props?: P,\n ...children: ReactNode[]): ReactHTMLElement;\n // SVGElement\n function cloneElement, T extends SVGElement>(\n element: ReactSVGElement,\n props?: P,\n ...children: ReactNode[]): ReactSVGElement;\n // DOM Element (has to be the last, because type checking stops at first overload that fits)\n function cloneElement
, T extends Element>(\n element: DOMElement,\n props?: DOMAttributes & P,\n ...children: ReactNode[]): DOMElement;\n\n // Custom components\n function cloneElement(\n element: FunctionComponentElement
,\n props?: Partial
& Attributes,\n ...children: ReactNode[]): FunctionComponentElement
;\n function cloneElement>(\n element: CElement,\n props?: Partial & ClassAttributes,\n ...children: ReactNode[]): CElement;\n function cloneElement(\n element: ReactElement
,\n props?: Partial
& Attributes,\n ...children: ReactNode[]): ReactElement
;\n\n // Context via RenderProps\n interface ProviderProps {\n value: T;\n children?: ReactNode;\n }\n\n interface ConsumerProps {\n children: (value: T) => ReactNode;\n unstable_observedBits?: number;\n }\n\n // TODO: similar to how Fragment is actually a symbol, the values returned from createContext,\n // forwardRef and memo are actually objects that are treated specially by the renderer; see:\n // https://github.com/facebook/react/blob/v16.6.0/packages/react/src/ReactContext.js#L35-L48\n // https://github.com/facebook/react/blob/v16.6.0/packages/react/src/forwardRef.js#L42-L45\n // https://github.com/facebook/react/blob/v16.6.0/packages/react/src/memo.js#L27-L31\n // However, we have no way of telling the JSX parser that it's a JSX element type or its props other than\n // by pretending to be a normal component.\n //\n // We don't just use ComponentType or SFC types because you are not supposed to attach statics to this\n // object, but rather to the original function.\n interface ExoticComponent {\n /**\n * **NOTE**: Exotic components are not callable.\n */\n (props: P): (ReactElement|null);\n readonly $$typeof: symbol;\n }\n\n interface NamedExoticComponent extends ExoticComponent
{\n displayName?: string;\n }\n\n interface ProviderExoticComponent
extends ExoticComponent
{\n propTypes?: WeakValidationMap
;\n }\n\n type ContextType> = C extends Context ? T : never;\n\n // NOTE: only the Context object itself can get a displayName\n // https://github.com/facebook/react-devtools/blob/e0b854e4c/backend/attachRendererFiber.js#L310-L325\n type Provider = ProviderExoticComponent>;\n type Consumer = ExoticComponent>;\n interface Context {\n Provider: Provider;\n Consumer: Consumer;\n displayName?: string;\n }\n function createContext(\n defaultValue: T,\n calculateChangedBits?: (prev: T, next: T) => number\n ): Context;\n\n function isValidElement(object: {} | null | undefined): object is ReactElement
;\n\n const Children: ReactChildren;\n const Fragment: ExoticComponent<{ children?: ReactNode }>;\n const StrictMode: ExoticComponent<{ children?: ReactNode }>;\n\n interface SuspenseProps {\n children?: ReactNode;\n\n /** A fallback react tree to show when a Suspense child (like React.lazy) suspends */\n fallback: NonNullable|null;\n\n // I tried looking at the code but I have no idea what it does.\n // https://github.com/facebook/react/issues/13206#issuecomment-432489986\n /**\n * Not implemented yet, requires unstable_ConcurrentMode\n */\n // maxDuration?: number;\n }\n /**\n * This feature is not yet available for server-side rendering.\n * Suspense support will be added in a later release.\n */\n const Suspense: ExoticComponent;\n const version: string;\n\n //\n // Component API\n // ----------------------------------------------------------------------\n\n type ReactInstance = Component | Element;\n\n // Base component for plain JS classes\n // tslint:disable-next-line:no-empty-interface\n interface Component extends ComponentLifecycle { }\n class Component {\n // tslint won't let me format the sample code in a way that vscode likes it :(\n /**\n * If set, `this.context` will be set at runtime to the current value of the given Context.\n *\n * Usage:\n *\n * ```ts\n * type MyContext = number\n * const Ctx = React.createContext(0)\n *\n * class Foo extends React.Component {\n * static contextType = Ctx\n * context!: React.ContextType\n * render () {\n * return <>My context's value: {this.context};\n * }\n * }\n * ```\n *\n * @see https://reactjs.org/docs/context.html#classcontexttype\n */\n static contextType?: Context;\n\n /**\n * If using the new style context, re-declare this in your class to be the\n * `React.ContextType` of your `static contextType`.\n *\n * ```ts\n * static contextType = MyContext\n * context!: React.ContextType\n * ```\n *\n * @deprecated if used without a type annotation, or without static contextType\n * @see https://reactjs.org/docs/legacy-context.html\n */\n // TODO (TypeScript 3.0): unknown\n context: any;\n\n constructor(props: Readonly);\n /**\n * @deprecated\n * @see https://reactjs.org/docs/legacy-context.html\n */\n constructor(props: P, context?: any);\n\n // We MUST keep setState() as a unified signature because it allows proper checking of the method return type.\n // See: https://github.com/DefinitelyTyped/DefinitelyTyped/issues/18365#issuecomment-351013257\n // Also, the ` | S` allows intellisense to not be dumbisense\n setState(\n state: ((prevState: Readonly, props: Readonly) => (Pick | S | null)) | (Pick | S | null),\n callback?: () => void\n ): void;\n\n forceUpdate(callBack?: () => void): void;\n render(): ReactNode;\n\n // React.Props is now deprecated, which means that the `children`\n // property is not available on `P` by default, even though you can\n // always pass children as variadic arguments to `createElement`.\n // In the future, if we can define its call signature conditionally\n // on the existence of `children` in `P`, then we should remove this.\n readonly props: Readonly<{ children?: ReactNode }> & Readonly;\n state: Readonly;\n /**\n * @deprecated\n * https://reactjs.org/docs/refs-and-the-dom.html#legacy-api-string-refs\n */\n refs: {\n [key: string]: ReactInstance\n };\n }\n\n class PureComponent
extends Component { }\n\n interface ClassicComponent extends Component {\n replaceState(nextState: S, callback?: () => void): void;\n isMounted(): boolean;\n getInitialState?(): S;\n }\n\n interface ChildContextProvider {\n getChildContext(): CC;\n }\n\n //\n // Class Interfaces\n // ----------------------------------------------------------------------\n\n /**\n * @deprecated as of recent React versions, function components can no\n * longer be considered 'stateless'. Please use `FunctionComponent` instead.\n *\n * @see [React Hooks](https://reactjs.org/docs/hooks-intro.html)\n */\n type SFC = FunctionComponent
;\n\n /**\n * @deprecated as of recent React versions, function components can no\n * longer be considered 'stateless'. Please use `FunctionComponent` instead.\n *\n * @see [React Hooks](https://reactjs.org/docs/hooks-intro.html)\n */\n type StatelessComponent
= FunctionComponent
;\n\n type FC
= FunctionComponent
;\n\n interface FunctionComponent
{\n (props: P & { children?: ReactNode }, context?: any): ReactElement | null;\n propTypes?: WeakValidationMap;\n contextTypes?: ValidationMap;\n defaultProps?: Partial;\n displayName?: string;\n }\n\n interface RefForwardingComponent {\n (props: P & { children?: ReactNode }, ref: Ref | null): ReactElement | null;\n propTypes?: WeakValidationMap;\n contextTypes?: ValidationMap;\n defaultProps?: Partial;\n displayName?: string;\n }\n\n interface ComponentClass
extends StaticLifecycle {\n new (props: P, context?: any): Component;\n propTypes?: WeakValidationMap;\n contextType?: Context;\n contextTypes?: ValidationMap;\n childContextTypes?: ValidationMap;\n defaultProps?: Partial;\n displayName?: string;\n }\n\n interface ClassicComponentClass
extends ComponentClass
{\n new (props: P, context?: any): ClassicComponent;\n getDefaultProps?(): P;\n }\n\n type JSXElementConstructor =\n | ((props: P) => ReactElement | null)\n | (new (props: P) => Component);\n\n /**\n * We use an intersection type to infer multiple type parameters from\n * a single argument, which is useful for many top-level API defs.\n * See https://github.com/Microsoft/TypeScript/issues/7234 for more info.\n */\n type ClassType, C extends ComponentClass> =\n C &\n (new (props: P, context?: any) => T);\n\n //\n // Component Specs and Lifecycle\n // ----------------------------------------------------------------------\n\n // This should actually be something like `Lifecycle | DeprecatedLifecycle`,\n // as React will _not_ call the deprecated lifecycle methods if any of the new lifecycle\n // methods are present.\n interface ComponentLifecycle extends NewLifecycle, DeprecatedLifecycle {\n /**\n * Called immediately after a component is mounted. Setting state here will trigger re-rendering.\n */\n componentDidMount?(): void;\n /**\n * Called to determine whether the change in props and state should trigger a re-render.\n *\n * `Component` always returns true.\n * `PureComponent` implements a shallow comparison on props and state and returns true if any\n * props or states have changed.\n *\n * If false is returned, `Component#render`, `componentWillUpdate`\n * and `componentDidUpdate` will not be called.\n */\n shouldComponentUpdate?(nextProps: Readonly, nextState: Readonly, nextContext: any): boolean;\n /**\n * Called immediately before a component is destroyed. Perform any necessary cleanup in this method, such as\n * cancelled network requests, or cleaning up any DOM elements created in `componentDidMount`.\n */\n componentWillUnmount?(): void;\n /**\n * Catches exceptions generated in descendant components. Unhandled exceptions will cause\n * the entire component tree to unmount.\n */\n componentDidCatch?(error: Error, errorInfo: ErrorInfo): void;\n }\n\n // Unfortunately, we have no way of declaring that the component constructor must implement this\n interface StaticLifecycle {\n getDerivedStateFromProps?: GetDerivedStateFromProps;\n getDerivedStateFromError?: GetDerivedStateFromError;\n }\n\n type GetDerivedStateFromProps =\n /**\n * Returns an update to a component's state based on its new props and old state.\n *\n * Note: its presence prevents any of the deprecated lifecycle methods from being invoked\n */\n (nextProps: Readonly, prevState: S) => Partial | null;\n\n type GetDerivedStateFromError =\n /**\n * This lifecycle is invoked after an error has been thrown by a descendant component.\n * It receives the error that was thrown as a parameter and should return a value to update state.\n *\n * Note: its presence prevents any of the deprecated lifecycle methods from being invoked\n */\n (error: any) => Partial | null;\n\n // This should be \"infer SS\" but can't use it yet\n interface NewLifecycle {\n /**\n * Runs before React applies the result of `render` to the document, and\n * returns an object to be given to componentDidUpdate. Useful for saving\n * things such as scroll position before `render` causes changes to it.\n *\n * Note: the presence of getSnapshotBeforeUpdate prevents any of the deprecated\n * lifecycle events from running.\n */\n getSnapshotBeforeUpdate?(prevProps: Readonly, prevState: Readonly): SS | null;\n /**\n * Called immediately after updating occurs. Not called for the initial render.\n *\n * The snapshot is only present if getSnapshotBeforeUpdate is present and returns non-null.\n */\n componentDidUpdate?(prevProps: Readonly
, prevState: Readonly, snapshot?: SS): void;\n }\n\n interface DeprecatedLifecycle {\n /**\n * Called immediately before mounting occurs, and before `Component#render`.\n * Avoid introducing any side-effects or subscriptions in this method.\n *\n * Note: the presence of getSnapshotBeforeUpdate or getDerivedStateFromProps\n * prevents this from being invoked.\n *\n * @deprecated 16.3, use componentDidMount or the constructor instead; will stop working in React 17\n * @see https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#initializing-state\n * @see https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#gradual-migration-path\n */\n componentWillMount?(): void;\n /**\n * Called immediately before mounting occurs, and before `Component#render`.\n * Avoid introducing any side-effects or subscriptions in this method.\n *\n * This method will not stop working in React 17.\n *\n * Note: the presence of getSnapshotBeforeUpdate or getDerivedStateFromProps\n * prevents this from being invoked.\n *\n * @deprecated 16.3, use componentDidMount or the constructor instead\n * @see https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#initializing-state\n * @see https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#gradual-migration-path\n */\n UNSAFE_componentWillMount?(): void;\n /**\n * Called when the component may be receiving new props.\n * React may call this even if props have not changed, so be sure to compare new and existing\n * props if you only want to handle changes.\n *\n * Calling `Component#setState` generally does not trigger this method.\n *\n * Note: the presence of getSnapshotBeforeUpdate or getDerivedStateFromProps\n * prevents this from being invoked.\n *\n * @deprecated 16.3, use static getDerivedStateFromProps instead; will stop working in React 17\n * @see https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#updating-state-based-on-props\n * @see https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#gradual-migration-path\n */\n componentWillReceiveProps?(nextProps: Readonly, nextContext: any): void;\n /**\n * Called when the component may be receiving new props.\n * React may call this even if props have not changed, so be sure to compare new and existing\n * props if you only want to handle changes.\n *\n * Calling `Component#setState` generally does not trigger this method.\n *\n * This method will not stop working in React 17.\n *\n * Note: the presence of getSnapshotBeforeUpdate or getDerivedStateFromProps\n * prevents this from being invoked.\n *\n * @deprecated 16.3, use static getDerivedStateFromProps instead\n * @see https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#updating-state-based-on-props\n * @see https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#gradual-migration-path\n */\n UNSAFE_componentWillReceiveProps?(nextProps: Readonly
, nextContext: any): void;\n /**\n * Called immediately before rendering when new props or state is received. Not called for the initial render.\n *\n * Note: You cannot call `Component#setState` here.\n *\n * Note: the presence of getSnapshotBeforeUpdate or getDerivedStateFromProps\n * prevents this from being invoked.\n *\n * @deprecated 16.3, use getSnapshotBeforeUpdate instead; will stop working in React 17\n * @see https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#reading-dom-properties-before-an-update\n * @see https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#gradual-migration-path\n */\n componentWillUpdate?(nextProps: Readonly
, nextState: Readonly, nextContext: any): void;\n /**\n * Called immediately before rendering when new props or state is received. Not called for the initial render.\n *\n * Note: You cannot call `Component#setState` here.\n *\n * This method will not stop working in React 17.\n *\n * Note: the presence of getSnapshotBeforeUpdate or getDerivedStateFromProps\n * prevents this from being invoked.\n *\n * @deprecated 16.3, use getSnapshotBeforeUpdate instead\n * @see https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#reading-dom-properties-before-an-update\n * @see https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#gradual-migration-path\n */\n UNSAFE_componentWillUpdate?(nextProps: Readonly
, nextState: Readonly, nextContext: any): void;\n }\n\n interface Mixin extends ComponentLifecycle {\n mixins?: Array>;\n statics?: {\n [key: string]: any;\n };\n\n displayName?: string;\n propTypes?: ValidationMap;\n contextTypes?: ValidationMap;\n childContextTypes?: ValidationMap;\n\n getDefaultProps?(): P;\n getInitialState?(): S;\n }\n\n interface ComponentSpec extends Mixin {\n render(): ReactNode;\n\n [propertyName: string]: any;\n }\n\n function createRef(): RefObject;\n\n // will show `ForwardRef(${Component.displayName || Component.name})` in devtools by default,\n // but can be given its own specific name\n interface ForwardRefExoticComponent extends NamedExoticComponent
{\n defaultProps?: Partial
;\n }\n\n function forwardRef(Component: RefForwardingComponent): ForwardRefExoticComponent & RefAttributes>;\n\n /** Ensures that the props do not include ref at all */\n type PropsWithoutRef =\n // Just Pick would be sufficient for this, but I'm trying to avoid unnecessary mapping over union types\n // https://github.com/Microsoft/TypeScript/issues/28339\n 'ref' extends keyof P\n ? Pick>\n : P;\n /** Ensures that the props do not include string ref, which cannot be forwarded */\n type PropsWithRef =\n // Just \"P extends { ref?: infer R }\" looks sufficient, but R will infer as {} if P is {}.\n 'ref' extends keyof P\n ? P extends { ref?: infer R }\n ? string extends R\n ? PropsWithoutRef
& { ref?: Exclude