Skip to main content
Module

std/types/react.d.ts

Deno standard library
Go to Latest
File
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564256525662567256825692570257125722573257425752576257725782579258025812582258325842585258625872588258925902591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618261926202621262226232624262526262627262826292630263126322633263426352636263726382639264026412642264326442645264626472648264926502651265226532654265526562657265826592660266126622663266426652666266726682669267026712672267326742675267626772678267926802681268226832684268526862687268826892690269126922693269426952696269726982699270027012702270327042705270627072708270927102711271227132714271527162717271827192720272127222723272427252726272727282729273027312732273327342735273627372738273927402741274227432744274527462747274827492750275127522753275427552756275727582759276027612762276327642765276627672768276927702771277227732774277527762777277827792780278127822783278427852786278727882789279027912792279327942795279627972798279928002801280228032804280528062807280828092810281128122813281428152816281728182819282028212822282328242825282628272828282928302831283228332834283528362837283828392840284128422843284428452846284728482849285028512852285328542855285628572858285928602861286228632864286528662867286828692870287128722873287428752876287728782879288028812882288328842885288628872888288928902891289228932894289528962897289828992900290129022903290429052906290729082909291029112912291329142915291629172918291929202921292229232924292529262927292829292930293129322933293429352936293729382939294029412942294329442945294629472948294929502951295229532954295529562957295829592960296129622963296429652966296729682969297029712972297329742975297629772978297929802981298229832984298529862987298829892990299129922993299429952996299729982999300030013002300330043005300630073008300930103011301230133014301530163017301830193020302130223023302430253026302730283029303030313032303330343035303630373038303930403041304230433044304530463047304830493050305130523053305430553056305730583059306030613062306330643065306630673068306930703071307230733074307530763077307830793080308130823083308430853086308730883089309030913092309330943095309630973098309931003101310231033104310531063107310831093110311131123113311431153116311731183119312031213122312331243125312631273128312931303131313231333134313531363137313831393140314131423143314431453146314731483149315031513152315331543155315631573158315931603161316231633164316531663167316831693170317131723173317431753176317731783179318031813182318331843185318631873188318931903191319231933194319531963197319831993200320132023203320432053206320732083209321032113212321332143215321632173218321932203221322232233224322532263227322832293230323132323233323432353236323732383239324032413242324332443245324632473248324932503251325232533254325532563257325832593260326132623263326432653266326732683269327032713272327332743275327632773278327932803281328232833284328532863287328832893290329132923293329432953296329732983299330033013302330333043305330633073308330933103311331233133314331533163317331833193320332133223323332433253326332733283329333033313332333333343335333633373338333933403341334233433344334533463347334833493350335133523353335433553356335733583359336033613362336333643365336633673368336933703371337233733374337533763377337833793380338133823383338433853386338733883389339033913392339333943395339633973398339934003401340234033404340534063407340834093410341134123413341434153416341734183419342034213422342334243425342634273428342934303431343234333434343534363437343834393440344134423443344434453446344734483449345034513452345334543455345634573458345934603461346234633464346534663467346834693470347134723473347434753476347734783479348034813482348334843485348634873488348934903491349234933494349534963497349834993500350135023503350435053506350735083509351035113512351335143515351635173518351935203521352235233524352535263527352835293530353135323533353435353536353735383539354035413542354335443545354635473548354935503551355235533554355535563557355835593560356135623563356435653566356735683569357035713572357335743575357635773578357935803581358235833584358535863587358835893590359135923593359435953596359735983599360036013602360336043605360636073608360936103611361236133614361536163617361836193620362136223623362436253626362736283629363036313632363336343635363636373638363936403641364236433644364536463647364836493650365136523653365436553656365736583659366036613662366336643665366636673668366936703671367236733674367536763677367836793680368136823683368436853686368736883689369036913692369336943695369636973698369937003701370237033704370537063707370837093710371137123713371437153716371737183719372037213722372337243725372637273728372937303731373237333734373537363737373837393740374137423743374437453746374737483749375037513752375337543755375637573758375937603761376237633764376537663767376837693770377137723773377437753776377737783779378037813782378337843785378637873788378937903791379237933794379537963797379837993800380138023803380438053806380738083809381038113812381338143815381638173818381938203821382238233824382538263827382838293830383138323833383438353836383738383839384038413842
// These types are adapted from// https://github.com/DefinitelyTyped/DefinitelyTyped to work under Deno.//// Type definitions for React 16.9// Project: http://facebook.github.io/react/// Definitions by: Asana <https://asana.com>// AssureSign <http://www.assuresign.com>// Microsoft <https://microsoft.com>// John Reilly <https://github.com/johnnyreilly>// Benoit Benezech <https://github.com/bbenezech>// Patricio Zavolinsky <https://github.com/pzavolinsky>// Digiguru <https://github.com/digiguru>// Eric Anderson <https://github.com/ericanderson>// Dovydas Navickas <https://github.com/DovydasNavickas>// Josh Rutherford <https://github.com/theruther4d>// Guilherme Hübner <https://github.com/guilhermehubner>// Ferdy Budhidharma <https://github.com/ferdaber>// Johann Rakotoharisoa <https://github.com/jrakotoharisoa>// Olivier Pascal <https://github.com/pascaloliv>// Martin Hochel <https://github.com/hotell>// Frank Li <https://github.com/franklixuefei>// Jessica Franco <https://github.com/Jessidhia>// Saransh Kataria <https://github.com/saranshkataria>// Kanitkorn Sujautra <https://github.com/lukyth>// Sebastian Silbermann <https://github.com/eps1lon>// Kyle Scully <https://github.com/zieka>// Cong Zhang <https://github.com/dancerphil>// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
/* eslint-disable */
import "./react/react_global.d.ts";
import * as CSS from "./react/csstype.d.ts";import * as PropTypes from "./react/prop-types.d.ts";
type NativeAnimationEvent = AnimationEvent;type NativeClipboardEvent = ClipboardEvent;type NativeCompositionEvent = CompositionEvent;type NativeDragEvent = DragEvent;type NativeFocusEvent = FocusEvent;type NativeKeyboardEvent = KeyboardEvent;type NativeMouseEvent = MouseEvent;type NativeTouchEvent = TouchEvent;type NativePointerEvent = PointerEvent;type NativeTransitionEvent = TransitionEvent;type NativeUIEvent = UIEvent;type NativeWheelEvent = WheelEvent;type Booleanish = boolean | "true" | "false";
/** * defined in scheduler/tracing */interface SchedulerInteraction { id: number; name: string; timestamp: number;}
// tslint:disable-next-line:export-just-namespaceexport = React;export as namespace React;
declare namespace React { // // React Elements // ---------------------------------------------------------------------- type ElementType<P = any> = | { [K in keyof JSX.IntrinsicElements]: P extends JSX.IntrinsicElements[K] ? K : never; }[keyof JSX.IntrinsicElements] | ComponentType<P>; /** * @deprecated Please use `ElementType` */ type ReactType<P = any> = ElementType<P>; type ComponentType<P = {}> = ComponentClass<P> | FunctionComponent<P>; type JSXElementConstructor<P> = | ((props: P) => ReactElement | null) | (new (props: P) => Component<P, any>); type Key = string | number; interface RefObject<T> { readonly current: T | null; } type Ref<T> = | { bivarianceHack(instance: T | null): void }["bivarianceHack"] | RefObject<T> | null; type LegacyRef<T> = string | Ref<T>; type ComponentState = any; /** * @internal You shouldn't need to use this type since you never see these attributes * inside your component or have to validate them. */ interface Attributes { key?: Key; } interface RefAttributes<T> extends Attributes { ref?: Ref<T>; } interface ClassAttributes<T> extends Attributes { ref?: LegacyRef<T>; } interface ReactElement< P = any, T extends string | JSXElementConstructor<any> = | string | JSXElementConstructor<any> > { type: T; props: P; key: Key | null; } interface ReactComponentElement< T extends keyof JSX.IntrinsicElements | JSXElementConstructor<any>, P = Pick<ComponentProps<T>, Exclude<keyof ComponentProps<T>, "key" | "ref">> > extends ReactElement<P, T> {} /** * @deprecated Please use `FunctionComponentElement` */ type SFCElement<P> = FunctionComponentElement<P>; interface FunctionComponentElement<P> extends ReactElement<P, FunctionComponent<P>> { ref?: "ref" extends keyof P ? P extends { ref?: infer R } ? R : never : never; } type CElement<P, T extends Component<P, ComponentState>> = ComponentElement< P, T >; interface ComponentElement<P, T extends Component<P, ComponentState>> extends ReactElement<P, ComponentClass<P>> { ref?: LegacyRef<T>; } type ClassicElement<P> = CElement<P, ClassicComponent<P, ComponentState>>; // string fallback for custom web-components interface DOMElement< P extends HTMLAttributes<T> | SVGAttributes<T>, T extends Element > extends ReactElement<P, string> { ref: LegacyRef<T>; } // ReactHTML for ReactHTMLElement // tslint:disable-next-line:no-empty-interface interface ReactHTMLElement<T extends HTMLElement> extends DetailedReactHTMLElement<AllHTMLAttributes<T>, T> {} interface DetailedReactHTMLElement< P extends HTMLAttributes<T>, T extends HTMLElement > extends DOMElement<P, T> { type: keyof ReactHTML; } // ReactSVG for ReactSVGElement interface ReactSVGElement extends DOMElement<SVGAttributes<SVGElement>, SVGElement> { type: keyof ReactSVG; } interface ReactPortal extends ReactElement { key: Key | null; children: ReactNode; } // // Factories // ---------------------------------------------------------------------- type Factory<P> = ( props?: Attributes & P, ...children: ReactNode[] ) => ReactElement<P>; /** * @deprecated Please use `FunctionComponentFactory` */ type SFCFactory<P> = FunctionComponentFactory<P>; type FunctionComponentFactory<P> = ( props?: Attributes & P, ...children: ReactNode[] ) => FunctionComponentElement<P>; type ComponentFactory<P, T extends Component<P, ComponentState>> = ( props?: ClassAttributes<T> & P, ...children: ReactNode[] ) => CElement<P, T>; type CFactory<P, T extends Component<P, ComponentState>> = ComponentFactory< P, T >; type ClassicFactory<P> = CFactory<P, ClassicComponent<P, ComponentState>>; type DOMFactory<P extends DOMAttributes<T>, T extends Element> = ( props?: (ClassAttributes<T> & P) | null, ...children: ReactNode[] ) => DOMElement<P, T>; // tslint:disable-next-line:no-empty-interface interface HTMLFactory<T extends HTMLElement> extends DetailedHTMLFactory<AllHTMLAttributes<T>, T> {} interface DetailedHTMLFactory< P extends HTMLAttributes<T>, T extends HTMLElement > extends DOMFactory<P, T> { ( props?: (ClassAttributes<T> & P) | null, ...children: ReactNode[] ): DetailedReactHTMLElement<P, T>; } interface SVGFactory extends DOMFactory<SVGAttributes<SVGElement>, SVGElement> { ( props?: (ClassAttributes<SVGElement> & SVGAttributes<SVGElement>) | null, ...children: ReactNode[] ): ReactSVGElement; } // // React Nodes // http://facebook.github.io/react/docs/glossary.html // ---------------------------------------------------------------------- type ReactText = string | number; type ReactChild = ReactElement | ReactText; interface ReactNodeArray extends Array<ReactNode> {} type ReactFragment = {} | ReactNodeArray; type ReactNode = | ReactChild | ReactFragment | ReactPortal | boolean | null | undefined; // // Top Level API // ---------------------------------------------------------------------- // DOM Elements function createFactory<T extends HTMLElement>( type: keyof ReactHTML ): HTMLFactory<T>; function createFactory(type: keyof ReactSVG): SVGFactory; function createFactory<P extends DOMAttributes<T>, T extends Element>( type: string ): DOMFactory<P, T>; // Custom components function createFactory<P>( type: FunctionComponent<P> ): FunctionComponentFactory<P>; function createFactory<P>( type: ClassType< P, ClassicComponent<P, ComponentState>, ClassicComponentClass<P> > ): CFactory<P, ClassicComponent<P, ComponentState>>; function createFactory< P, T extends Component<P, ComponentState>, C extends ComponentClass<P> >(type: ClassType<P, T, C>): CFactory<P, T>; function createFactory<P>(type: ComponentClass<P>): Factory<P>; // DOM Elements // TODO: generalize this to everything in `keyof ReactHTML`, not just "input" function createElement( type: "input", props?: | (InputHTMLAttributes<HTMLInputElement> & ClassAttributes<HTMLInputElement>) | null, ...children: ReactNode[] ): DetailedReactHTMLElement< InputHTMLAttributes<HTMLInputElement>, HTMLInputElement >; function createElement<P extends HTMLAttributes<T>, T extends HTMLElement>( type: keyof ReactHTML, props?: (ClassAttributes<T> & P) | null, ...children: ReactNode[] ): DetailedReactHTMLElement<P, T>; function createElement<P extends SVGAttributes<T>, T extends SVGElement>( type: keyof ReactSVG, props?: (ClassAttributes<T> & P) | null, ...children: ReactNode[] ): ReactSVGElement; function createElement<P extends DOMAttributes<T>, T extends Element>( type: string, props?: (ClassAttributes<T> & P) | null, ...children: ReactNode[] ): DOMElement<P, T>; // Custom components function createElement<P extends {}>( type: FunctionComponent<P>, props?: (Attributes & P) | null, ...children: ReactNode[] ): FunctionComponentElement<P>; function createElement<P extends {}>( type: ClassType< P, ClassicComponent<P, ComponentState>, ClassicComponentClass<P> >, props?: (ClassAttributes<ClassicComponent<P, ComponentState>> & P) | null, ...children: ReactNode[] ): CElement<P, ClassicComponent<P, ComponentState>>; function createElement< P extends {}, T extends Component<P, ComponentState>, C extends ComponentClass<P> >( type: ClassType<P, T, C>, props?: (ClassAttributes<T> & P) | null, ...children: ReactNode[] ): CElement<P, T>; function createElement<P extends {}>( type: FunctionComponent<P> | ComponentClass<P> | string, props?: (Attributes & P) | null, ...children: ReactNode[] ): ReactElement<P>; // DOM Elements // ReactHTMLElement function cloneElement<P extends HTMLAttributes<T>, T extends HTMLElement>( element: DetailedReactHTMLElement<P, T>, props?: P, ...children: ReactNode[] ): DetailedReactHTMLElement<P, T>; // ReactHTMLElement, less specific function cloneElement<P extends HTMLAttributes<T>, T extends HTMLElement>( element: ReactHTMLElement<T>, props?: P, ...children: ReactNode[] ): ReactHTMLElement<T>; // SVGElement function cloneElement<P extends SVGAttributes<T>, T extends SVGElement>( element: ReactSVGElement, props?: P, ...children: ReactNode[] ): ReactSVGElement; // DOM Element (has to be the last, because type checking stops at first overload that fits) function cloneElement<P extends DOMAttributes<T>, T extends Element>( element: DOMElement<P, T>, props?: DOMAttributes<T> & P, ...children: ReactNode[] ): DOMElement<P, T>; // Custom components function cloneElement<P>( element: FunctionComponentElement<P>, props?: Partial<P> & Attributes, ...children: ReactNode[] ): FunctionComponentElement<P>; function cloneElement<P, T extends Component<P, ComponentState>>( element: CElement<P, T>, props?: Partial<P> & ClassAttributes<T>, ...children: ReactNode[] ): CElement<P, T>; function cloneElement<P>( element: ReactElement<P>, props?: Partial<P> & Attributes, ...children: ReactNode[] ): ReactElement<P>; // Context via RenderProps interface ProviderProps<T> { value: T; children?: ReactNode; } interface ConsumerProps<T> { children: (value: T) => ReactNode; unstable_observedBits?: number; } // TODO: similar to how Fragment is actually a symbol, the values returned from createContext, // forwardRef and memo are actually objects that are treated specially by the renderer; see: // https://github.com/facebook/react/blob/v16.6.0/packages/react/src/ReactContext.js#L35-L48 // https://github.com/facebook/react/blob/v16.6.0/packages/react/src/forwardRef.js#L42-L45 // https://github.com/facebook/react/blob/v16.6.0/packages/react/src/memo.js#L27-L31 // However, we have no way of telling the JSX parser that it's a JSX element type or its props other than // by pretending to be a normal component. // // We don't just use ComponentType or SFC types because you are not supposed to attach statics to this // object, but rather to the original function. interface ExoticComponent<P = {}> { /** * **NOTE**: Exotic components are not callable. */ (props: P): ReactElement | null; readonly $$typeof: symbol; } interface NamedExoticComponent<P = {}> extends ExoticComponent<P> { displayName?: string; } interface ProviderExoticComponent<P> extends ExoticComponent<P> { propTypes?: WeakValidationMap<P>; } type ContextType<C extends Context<any>> = C extends Context<infer T> ? T : never; // NOTE: only the Context object itself can get a displayName // https://github.com/facebook/react-devtools/blob/e0b854e4c/backend/attachRendererFiber.js#L310-L325 type Provider<T> = ProviderExoticComponent<ProviderProps<T>>; type Consumer<T> = ExoticComponent<ConsumerProps<T>>; interface Context<T> { Provider: Provider<T>; Consumer: Consumer<T>; displayName?: string; } function createContext<T>( // If you thought this should be optional, see // https://github.com/DefinitelyTyped/DefinitelyTyped/pull/24509#issuecomment-382213106 defaultValue: T, calculateChangedBits?: (prev: T, next: T) => number ): Context<T>; function isValidElement<P>( object: {} | null | undefined ): object is ReactElement<P>; const Children: ReactChildren; const Fragment: ExoticComponent<{ children?: ReactNode }>; const StrictMode: ExoticComponent<{ children?: ReactNode }>; interface SuspenseProps { children?: ReactNode; /** A fallback react tree to show when a Suspense child (like React.lazy) suspends */ fallback: NonNullable<ReactNode> | null; /** * Tells React whether to “skip” revealing this boundary during the initial load. * This API will likely be removed in a future release. */ // NOTE: this is unflagged and is respected even in stable builds unstable_avoidThisFallback?: boolean; } /** * This feature is not yet available for server-side rendering. * Suspense support will be added in a later release. */ const Suspense: ExoticComponent<SuspenseProps>; const version: string; /** * {@link https://github.com/bvaughn/rfcs/blob/profiler/text/0000-profiler.md#detailed-design | API} */ type ProfilerOnRenderCallback = ( id: string, phase: "mount" | "update", actualDuration: number, baseDuration: number, startTime: number, commitTime: number, interactions: Set<SchedulerInteraction> ) => void; interface ProfilerProps { children?: ReactNode; id: string; onRender: ProfilerOnRenderCallback; } const Profiler: ExoticComponent<ProfilerProps>; // // Component API // ---------------------------------------------------------------------- type ReactInstance = Component<any> | Element; // Base component for plain JS classes // tslint:disable-next-line:no-empty-interface interface Component<P = {}, S = {}, SS = any> extends ComponentLifecycle<P, S, SS> {} class Component<P, S> { // tslint won't let me format the sample code in a way that vscode likes it :( /** * If set, `this.context` will be set at runtime to the current value of the given Context. * * Usage: * * ```ts * 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 https://reactjs.org/docs/context.html#classcontexttype */ static contextType?: 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. * * ```ts * 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 https://reactjs.org/docs/context.html */ // TODO (TypeScript 3.0): unknown context: any; constructor(props: Readonly<P>); /** * @deprecated * @see https://reactjs.org/docs/legacy-context.html */ constructor(props: P, context?: any); // We MUST keep setState() as a unified signature because it allows proper checking of the method return type. // See: https://github.com/DefinitelyTyped/DefinitelyTyped/issues/18365#issuecomment-351013257 // Also, the ` | S` allows intellisense to not be dumbisense setState<K extends keyof S>( state: | (( prevState: Readonly<S>, props: Readonly<P> ) => Pick<S, K> | S | null) | (Pick<S, K> | S | null), callback?: () => void ): void; forceUpdate(callback?: () => void): void; render(): ReactNode; // React.Props<T> is now deprecated, which means that the `children` // property is not available on `P` by default, even though you can // always pass children as variadic arguments to `createElement`. // In the future, if we can define its call signature conditionally // on the existence of `children` in `P`, then we should remove this. readonly props: Readonly<P> & Readonly<{ children?: ReactNode }>; state: Readonly<S>; /** * @deprecated * https://reactjs.org/docs/refs-and-the-dom.html#legacy-api-string-refs */ refs: { [key: string]: ReactInstance; }; } class PureComponent<P = {}, S = {}, SS = any> extends Component<P, S, SS> {} interface ClassicComponent<P = {}, S = {}> extends Component<P, S> { replaceState(nextState: S, callback?: () => void): void; isMounted(): boolean; getInitialState?(): S; } interface ChildContextProvider<CC> { getChildContext(): CC; } // // Class Interfaces // ---------------------------------------------------------------------- /** * @deprecated as of recent React versions, function components can no * longer be considered 'stateless'. Please use `FunctionComponent` instead. * * @see [React Hooks](https://reactjs.org/docs/hooks-intro.html) */ type SFC<P = {}> = FunctionComponent<P>; /** * @deprecated as of recent React versions, function components can no * longer be considered 'stateless'. Please use `FunctionComponent` instead. * * @see [React Hooks](https://reactjs.org/docs/hooks-intro.html) */ type StatelessComponent<P = {}> = FunctionComponent<P>; type FC<P = {}> = FunctionComponent<P>; interface FunctionComponent<P = {}> { (props: PropsWithChildren<P>, context?: any): ReactElement | null; propTypes?: WeakValidationMap<P>; contextTypes?: ValidationMap<any>; defaultProps?: Partial<P>; displayName?: string; } interface RefForwardingComponent<T, P = {}> { (props: PropsWithChildren<P>, ref: Ref<T>): ReactElement | null; propTypes?: WeakValidationMap<P>; contextTypes?: ValidationMap<any>; defaultProps?: Partial<P>; displayName?: string; } interface ComponentClass<P = {}, S = ComponentState> extends StaticLifecycle<P, S> { new (props: P, context?: any): Component<P, S>; propTypes?: WeakValidationMap<P>; contextType?: Context<any>; contextTypes?: ValidationMap<any>; childContextTypes?: ValidationMap<any>; defaultProps?: Partial<P>; displayName?: string; } interface ClassicComponentClass<P = {}> extends ComponentClass<P> { new (props: P, context?: any): ClassicComponent<P, ComponentState>; getDefaultProps?(): P; } /** * We use an intersection type to infer multiple type parameters from * a single argument, which is useful for many top-level API defs. * See https://github.com/Microsoft/TypeScript/issues/7234 for more info. */ type ClassType< P, T extends Component<P, ComponentState>, C extends ComponentClass<P> > = C & (new (props: P, context?: any) => T); // // Component Specs and Lifecycle // ---------------------------------------------------------------------- // This should actually be something like `Lifecycle<P, S> | DeprecatedLifecycle<P, S>`, // as React will _not_ call the deprecated lifecycle methods if any of the new lifecycle // methods are present. interface ComponentLifecycle<P, S, SS = any> extends NewLifecycle<P, S, SS>, DeprecatedLifecycle<P, S> { /** * Called immediately after a component is mounted. Setting state here will trigger re-rendering. */ componentDidMount?(): void; /** * Called to determine whether the change in props and state should trigger a re-render. * * `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. */ shouldComponentUpdate?( nextProps: Readonly<P>, nextState: Readonly<S>, nextContext: any ): boolean; /** * Called immediately before a component is destroyed. Perform any necessary cleanup in this method, such as * cancelled network requests, or cleaning up any DOM elements created in `componentDidMount`. */ componentWillUnmount?(): void; /** * Catches exceptions generated in descendant components. Unhandled exceptions will cause * the entire component tree to unmount. */ componentDidCatch?(error: Error, errorInfo: ErrorInfo): void; } // Unfortunately, we have no way of declaring that the component constructor must implement this interface StaticLifecycle<P, S> { getDerivedStateFromProps?: GetDerivedStateFromProps<P, S>; getDerivedStateFromError?: GetDerivedStateFromError<P, S>; } type GetDerivedStateFromProps<P, S> = /** * Returns an update to a component's state based on its new props and old state. * * Note: its presence prevents any of the deprecated lifecycle methods from being invoked */ (nextProps: Readonly<P>, prevState: S) => Partial<S> | null; type GetDerivedStateFromError<P, S> = /** * This lifecycle is invoked after an error has been thrown by a descendant component. * It receives the error that was thrown as a parameter and should return a value to update state. * * Note: its presence prevents any of the deprecated lifecycle methods from being invoked */ (error: any) => Partial<S> | null; // This should be "infer SS" but can't use it yet interface NewLifecycle<P, S, SS> { /** * Runs before React applies the result of `render` to the document, and * returns an object to be given to componentDidUpdate. Useful for saving * things such as scroll position before `render` causes changes to it. * * Note: the presence of getSnapshotBeforeUpdate prevents any of the deprecated * lifecycle events from running. */ getSnapshotBeforeUpdate?( prevProps: Readonly<P>, prevState: Readonly<S> ): SS | null; /** * Called immediately after updating occurs. Not called for the initial render. * * The snapshot is only present if getSnapshotBeforeUpdate is present and returns non-null. */ componentDidUpdate?( prevProps: Readonly<P>, prevState: Readonly<S>, snapshot?: SS ): void; } interface DeprecatedLifecycle<P, S> { /** * 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. * * @deprecated 16.3, use componentDidMount or the constructor instead; will stop working in React 17 * @see https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#initializing-state * @see https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#gradual-migration-path */ 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. * * @deprecated 16.3, use componentDidMount or the constructor instead * @see https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#initializing-state * @see https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#gradual-migration-path */ UNSAFE_componentWillMount?(): void; /** * Called when the component may be receiving new props. * React may call this even if props have not changed, so be sure to compare new and existing * props if you only want to handle changes. * * Calling `Component#setState` generally does not trigger this method. * * Note: the presence of getSnapshotBeforeUpdate or getDerivedStateFromProps * prevents this from being invoked. * * @deprecated 16.3, use static getDerivedStateFromProps instead; will stop working in React 17 * @see https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#updating-state-based-on-props * @see https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#gradual-migration-path */ componentWillReceiveProps?(nextProps: Readonly<P>, nextContext: any): void; /** * Called when the component may be receiving new props. * React may call this even if props have not changed, so be sure to compare new and existing * props if you only want to handle changes. * * 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. * * @deprecated 16.3, use static getDerivedStateFromProps instead * @see https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#updating-state-based-on-props * @see https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#gradual-migration-path */ UNSAFE_componentWillReceiveProps?( nextProps: Readonly<P>, nextContext: any ): void; /** * Called immediately before rendering when new props or state is received. Not called for the initial render. * * Note: You cannot call `Component#setState` here. * * Note: the presence of getSnapshotBeforeUpdate or getDerivedStateFromProps * prevents this from being invoked. * * @deprecated 16.3, use getSnapshotBeforeUpdate instead; will stop working in React 17 * @see https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#reading-dom-properties-before-an-update * @see https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#gradual-migration-path */ componentWillUpdate?( nextProps: Readonly<P>, nextState: Readonly<S>, nextContext: any ): void; /** * Called immediately before rendering when new props or state is received. Not called for the initial render. * * 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. * * @deprecated 16.3, use getSnapshotBeforeUpdate instead * @see https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#reading-dom-properties-before-an-update * @see https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#gradual-migration-path */ UNSAFE_componentWillUpdate?( nextProps: Readonly<P>, nextState: Readonly<S>, nextContext: any ): void; } interface Mixin<P, S> extends ComponentLifecycle<P, S> { mixins?: Array<Mixin<P, S>>; statics?: { [key: string]: any; }; displayName?: string; propTypes?: ValidationMap<any>; contextTypes?: ValidationMap<any>; childContextTypes?: ValidationMap<any>; getDefaultProps?(): P; getInitialState?(): S; } interface ComponentSpec<P, S> extends Mixin<P, S> { render(): ReactNode; [propertyName: string]: any; } function createRef<T>(): RefObject<T>; // will show `ForwardRef(${Component.displayName || Component.name})` in devtools by default, // but can be given its own specific name interface ForwardRefExoticComponent<P> extends NamedExoticComponent<P> { defaultProps?: Partial<P>; propTypes?: WeakValidationMap<P>; } function forwardRef<T, P = {}>( Component: RefForwardingComponent<T, P> ): ForwardRefExoticComponent<PropsWithoutRef<P> & RefAttributes<T>>; /** Ensures that the props do not include ref at all */ type PropsWithoutRef<P> = // Just Pick would be sufficient for this, but I'm trying to avoid unnecessary mapping over union types // https://github.com/Microsoft/TypeScript/issues/28339 "ref" extends keyof P ? Pick<P, Exclude<keyof P, "ref">> : P; /** Ensures that the props do not include string ref, which cannot be forwarded */ type PropsWithRef<P> = // Just "P extends { ref?: infer R }" looks sufficient, but R will infer as {} if P is {}. "ref" extends keyof P ? P extends { ref?: infer R } ? string extends R ? PropsWithoutRef<P> & { ref?: Exclude<R, string> } : P : P : P; type PropsWithChildren<P> = P & { children?: ReactNode }; /** * NOTE: prefer ComponentPropsWithRef, if the ref is forwarded, * or ComponentPropsWithoutRef when refs are not supported. */ type ComponentProps< T extends keyof JSX.IntrinsicElements | JSXElementConstructor<any> > = T extends JSXElementConstructor<infer P> ? P : T extends keyof JSX.IntrinsicElements ? JSX.IntrinsicElements[T] : {}; type ComponentPropsWithRef<T extends ElementType> = T extends ComponentClass< infer P > ? PropsWithoutRef<P> & RefAttributes<InstanceType<T>> : PropsWithRef<ComponentProps<T>>; type ComponentPropsWithoutRef<T extends ElementType> = PropsWithoutRef< ComponentProps<T> >; // will show `Memo(${Component.displayName || Component.name})` in devtools by default, // but can be given its own specific name type MemoExoticComponent<T extends ComponentType<any>> = NamedExoticComponent< ComponentPropsWithRef<T> > & { readonly type: T; }; function memo<P extends object>( Component: SFC<P>, propsAreEqual?: ( prevProps: Readonly<PropsWithChildren<P>>, nextProps: Readonly<PropsWithChildren<P>> ) => boolean ): NamedExoticComponent<P>; function memo<T extends ComponentType<any>>( Component: T, propsAreEqual?: ( prevProps: Readonly<ComponentProps<T>>, nextProps: Readonly<ComponentProps<T>> ) => boolean ): MemoExoticComponent<T>; type LazyExoticComponent<T extends ComponentType<any>> = ExoticComponent< ComponentPropsWithRef<T> > & { readonly _result: T; }; function lazy<T extends ComponentType<any>>( factory: () => Promise<{ default: T }> ): LazyExoticComponent<T>; // // React Hooks // ---------------------------------------------------------------------- // based on the code in https://github.com/facebook/react/pull/13968 // Unlike the class component setState, the updates are not allowed to be partial type SetStateAction<S> = S | ((prevState: S) => S); // this technically does accept a second argument, but it's already under a deprecation warning // and it's not even released so probably better to not define it. type Dispatch<A> = (value: A) => void; // Since action _can_ be undefined, dispatch may be called without any parameters. type DispatchWithoutAction = () => void; // Unlike redux, the actions _can_ be anything type Reducer<S, A> = (prevState: S, action: A) => S; // If useReducer accepts a reducer without action, dispatch may be called without any parameters. type ReducerWithoutAction<S> = (prevState: S) => S; // types used to try and prevent the compiler from reducing S // to a supertype common with the second argument to useReducer() type ReducerState<R extends Reducer<any, any>> = R extends Reducer< infer S, any > ? S : never; type ReducerAction<R extends Reducer<any, any>> = R extends Reducer< any, infer A > ? A : never; // The identity check is done with the SameValue algorithm (Object.is), which is stricter than === type ReducerStateWithoutAction< R extends ReducerWithoutAction<any> > = R extends ReducerWithoutAction<infer S> ? S : never; // TODO (TypeScript 3.0): ReadonlyArray<unknown> type DependencyList = ReadonlyArray<any>; // NOTE: callbacks are _only_ allowed to return either void, or a destructor. // The destructor is itself only allowed to return void. type EffectCallback = () => void | (() => void | undefined); interface MutableRefObject<T> { current: T; } // This will technically work if you give a Consumer<T> or Provider<T> but it's deprecated and warns /** * 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. * * @version 16.8.0 * @see https://reactjs.org/docs/hooks-reference.html#usecontext */ function useContext<T>( context: Context<T> /*, (not public API) observedBits?: number|boolean */ ): T; /** * Returns a stateful value, and a function to update it. * * @version 16.8.0 * @see https://reactjs.org/docs/hooks-reference.html#usestate */ function useState<S>( initialState: S | (() => S) ): [S, Dispatch<SetStateAction<S>>]; // convenience overload when first argument is ommitted /** * Returns a stateful value, and a function to update it. * * @version 16.8.0 * @see https://reactjs.org/docs/hooks-reference.html#usestate */ function useState<S = undefined>(): [ S | undefined, Dispatch<SetStateAction<S | undefined>> ]; /** * 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. * * @version 16.8.0 * @see https://reactjs.org/docs/hooks-reference.html#usereducer */ // overload where dispatch could accept 0 arguments. function useReducer<R extends ReducerWithoutAction<any>, I>( reducer: R, initializerArg: I, initializer: (arg: I) => ReducerStateWithoutAction<R> ): [ReducerStateWithoutAction<R>, DispatchWithoutAction]; /** * 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. * * @version 16.8.0 * @see https://reactjs.org/docs/hooks-reference.html#usereducer */ // overload where dispatch could accept 0 arguments. function useReducer<R extends ReducerWithoutAction<any>>( reducer: R, initializerArg: ReducerStateWithoutAction<R>, initializer?: undefined ): [ReducerStateWithoutAction<R>, DispatchWithoutAction]; /** * 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. * * @version 16.8.0 * @see https://reactjs.org/docs/hooks-reference.html#usereducer */ // overload where "I" may be a subset of ReducerState<R>; used to provide autocompletion. // If "I" matches ReducerState<R> exactly then the last overload will allow initializer to be ommitted. // the last overload effectively behaves as if the identity function (x => x) is the initializer. function useReducer<R extends Reducer<any, any>, I>( reducer: R, initializerArg: I & ReducerState<R>, initializer: (arg: I & ReducerState<R>) => ReducerState<R> ): [ReducerState<R>, Dispatch<ReducerAction<R>>]; /** * An alternative to `useState`. * * `useReducer` is usually preferable to `useState` when you have complex state logic that involves * multiple sub-values. It also lets you optimize performance for components that trigger deep * updates because you can pass `dispatch` down instead of callbacks. * * @version 16.8.0 * @see https://reactjs.org/docs/hooks-reference.html#usereducer */ // overload for free "I"; all goes as long as initializer converts it into "ReducerState<R>". function useReducer<R extends Reducer<any, any>, I>( reducer: R, initializerArg: I, initializer: (arg: I) => ReducerState<R> ): [ReducerState<R>, Dispatch<ReducerAction<R>>]; /** * An alternative to `useState`. * * `useReducer` is usually preferable to `useState` when you have complex state logic that involves * multiple sub-values. It also lets you optimize performance for components that trigger deep * updates because you can pass `dispatch` down instead of callbacks. * * @version 16.8.0 * @see https://reactjs.org/docs/hooks-reference.html#usereducer */ // I'm not sure if I keep this 2-ary or if I make it (2,3)-ary; it's currently (2,3)-ary. // The Flow types do have an overload for 3-ary invocation with undefined initializer. // NOTE: without the ReducerState indirection, TypeScript would reduce S to be the most common // supertype between the reducer's return type and the initialState (or the initializer's return type), // which would prevent autocompletion from ever working. // TODO: double-check if this weird overload logic is necessary. It is possible it's either a bug // in older versions, or a regression in newer versions of the typescript completion service. function useReducer<R extends Reducer<any, any>>( reducer: R, initialState: ReducerState<R>, initializer?: undefined ): [ReducerState<R>, Dispatch<ReducerAction<R>>]; /** * `useRef` returns a mutable ref object whose `.current` property is initialized to the passed argument * (`initialValue`). The returned object will persist for the full lifetime of the component. * * Note that `useRef()` is useful for more than the `ref` attribute. It’s handy for keeping any mutable * value around similar to how you’d use instance fields in classes. * * @version 16.8.0 * @see https://reactjs.org/docs/hooks-reference.html#useref */ // TODO (TypeScript 3.0): <T extends unknown> function useRef<T>(initialValue: T): MutableRefObject<T>; // convenience overload for refs given as a ref prop as they typically start with a null value /** * `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. * * @version 16.8.0 * @see https://reactjs.org/docs/hooks-reference.html#useref */ // TODO (TypeScript 3.0): <T extends unknown> function useRef<T>(initialValue: T | null): RefObject<T>; // convenience overload for potentially undefined initialValue / call with 0 arguments // has a default to stop it from defaulting to {} instead /** * `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. * * @version 16.8.0 * @see https://reactjs.org/docs/hooks-reference.html#useref */ // TODO (TypeScript 3.0): <T extends unknown> function useRef<T = undefined>(): MutableRefObject<T | undefined>; /** * The signature is identical to `useEffect`, but it fires synchronously after all DOM mutations. * Use this to read layout from the DOM and synchronously re-render. Updates scheduled inside * `useLayoutEffect` will be flushed synchronously, before the browser has a chance to paint. * * Prefer the standard `useEffect` when possible to avoid blocking visual updates. * * If you’re migrating code from a class component, `useLayoutEffect` fires in the same phase as * `componentDidMount` and `componentDidUpdate`. * * @version 16.8.0 * @see https://reactjs.org/docs/hooks-reference.html#uselayouteffect */ function useLayoutEffect(effect: EffectCallback, deps?: DependencyList): void; /** * Accepts a function that contains imperative, possibly effectful code. * * @param effect Imperative function that can return a cleanup function * @param deps If present, effect will only activate if the values in the list change. * * @version 16.8.0 * @see https://reactjs.org/docs/hooks-reference.html#useeffect */ function useEffect(effect: EffectCallback, deps?: DependencyList): void; // NOTE: this does not accept strings, but this will have to be fixed by removing strings from type Ref<T> /** * `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`. * * @version 16.8.0 * @see https://reactjs.org/docs/hooks-reference.html#useimperativehandle */ function useImperativeHandle<T, R extends T>( ref: Ref<T> | undefined, init: () => R, deps?: DependencyList ): void; // I made 'inputs' required here and in useMemo as there's no point to memoizing without the memoization key // useCallback(X) is identical to just using X, useMemo(() => Y) is identical to just using Y. /** * `useCallback` will return a memoized version of the callback that only changes if one of the `inputs` * has changed. * * @version 16.8.0 * @see https://reactjs.org/docs/hooks-reference.html#usecallback */ // TODO (TypeScript 3.0): <T extends (...args: never[]) => unknown> function useCallback<T extends (...args: any[]) => any>( callback: T, deps: DependencyList ): 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. * * ```ts * function expensive () { ... } * * function Component () { * const expensiveResult = useMemo(expensive, [expensive]) * return ... * } * ``` * * @version 16.8.0 * @see https://reactjs.org/docs/hooks-reference.html#usememo */ // allow undefined, but don't make it optional as that is very likely a mistake function useMemo<T>(factory: () => T, deps: DependencyList | undefined): T; /** * `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. * * @version 16.8.0 * @see https://reactjs.org/docs/hooks-reference.html#usedebugvalue */ // the name of the custom hook is itself derived from the function name at runtime: // it's just the function name without the "use" prefix. function useDebugValue<T>(value: T, format?: (value: T) => any): void; // // Event System // ---------------------------------------------------------------------- // TODO: change any to unknown when moving to TS v3 interface BaseSyntheticEvent<E = object, C = any, T = any> { nativeEvent: E; currentTarget: C; target: T; bubbles: boolean; cancelable: boolean; defaultPrevented: boolean; eventPhase: number; isTrusted: boolean; preventDefault(): void; isDefaultPrevented(): boolean; stopPropagation(): void; isPropagationStopped(): boolean; persist(): void; timeStamp: number; type: string; } /** * currentTarget - a reference to the element on which the event listener is registered. * * target - a reference to the element from which the event was originally dispatched. * This might be a child element to the element on which the event listener is registered. * If you thought this should be `EventTarget & T`, see https://github.com/DefinitelyTyped/DefinitelyTyped/pull/12239 */ interface SyntheticEvent<T = Element, E = Event> extends BaseSyntheticEvent<E, EventTarget & T, EventTarget> {} interface ClipboardEvent<T = Element> extends SyntheticEvent<T, NativeClipboardEvent> { clipboardData: DataTransfer; } interface CompositionEvent<T = Element> extends SyntheticEvent<T, NativeCompositionEvent> { data: string; } interface DragEvent<T = Element> extends MouseEvent<T, NativeDragEvent> { dataTransfer: DataTransfer; } interface PointerEvent<T = Element> extends MouseEvent<T, NativePointerEvent> { pointerId: number; pressure: number; tiltX: number; tiltY: number; width: number; height: number; pointerType: "mouse" | "pen" | "touch"; isPrimary: boolean; } interface FocusEvent<T = Element> extends SyntheticEvent<T, NativeFocusEvent> { relatedTarget: EventTarget | null; target: EventTarget & T; } // tslint:disable-next-line:no-empty-interface interface FormEvent<T = Element> extends SyntheticEvent<T> {} interface InvalidEvent<T = Element> extends SyntheticEvent<T> { target: EventTarget & T; } interface ChangeEvent<T = Element> extends SyntheticEvent<T> { target: EventTarget & T; } interface KeyboardEvent<T = Element> extends SyntheticEvent<T, NativeKeyboardEvent> { altKey: boolean; charCode: number; ctrlKey: boolean; /** * See [DOM Level 3 Events spec](https://www.w3.org/TR/uievents-key/#keys-modifier). for a list of valid (case-sensitive) arguments to this method. */ getModifierState(key: string): boolean; /** * See the [DOM Level 3 Events spec](https://www.w3.org/TR/uievents-key/#named-key-attribute-values). for possible values */ key: string; keyCode: number; locale: string; location: number; metaKey: boolean; repeat: boolean; shiftKey: boolean; which: number; } interface MouseEvent<T = Element, E = NativeMouseEvent> extends SyntheticEvent<T, E> { altKey: boolean; button: number; buttons: number; clientX: number; clientY: number; ctrlKey: boolean; /** * See [DOM Level 3 Events spec](https://www.w3.org/TR/uievents-key/#keys-modifier). for a list of valid (case-sensitive) arguments to this method. */ getModifierState(key: string): boolean; metaKey: boolean; movementX: number; movementY: number; pageX: number; pageY: number; relatedTarget: EventTarget | null; screenX: number; screenY: number; shiftKey: boolean; } interface TouchEvent<T = Element> extends SyntheticEvent<T, NativeTouchEvent> { altKey: boolean; changedTouches: TouchList; ctrlKey: boolean; /** * See [DOM Level 3 Events spec](https://www.w3.org/TR/uievents-key/#keys-modifier). for a list of valid (case-sensitive) arguments to this method. */ getModifierState(key: string): boolean; metaKey: boolean; shiftKey: boolean; targetTouches: TouchList; touches: TouchList; } interface UIEvent<T = Element> extends SyntheticEvent<T, NativeUIEvent> { detail: number; view: AbstractView; } interface WheelEvent<T = Element> extends MouseEvent<T, NativeWheelEvent> { deltaMode: number; deltaX: number; deltaY: number; deltaZ: number; } interface AnimationEvent<T = Element> extends SyntheticEvent<T, NativeAnimationEvent> { animationName: string; elapsedTime: number; pseudoElement: string; } interface TransitionEvent<T = Element> extends SyntheticEvent<T, NativeTransitionEvent> { elapsedTime: number; propertyName: string; pseudoElement: string; } // // Event Handler Types // ---------------------------------------------------------------------- type EventHandler<E extends SyntheticEvent<any>> = { bivarianceHack(event: E): void; }["bivarianceHack"]; type ReactEventHandler<T = Element> = EventHandler<SyntheticEvent<T>>; type ClipboardEventHandler<T = Element> = EventHandler<ClipboardEvent<T>>; type CompositionEventHandler<T = Element> = EventHandler<CompositionEvent<T>>; type DragEventHandler<T = Element> = EventHandler<DragEvent<T>>; type FocusEventHandler<T = Element> = EventHandler<FocusEvent<T>>; type FormEventHandler<T = Element> = EventHandler<FormEvent<T>>; type ChangeEventHandler<T = Element> = EventHandler<ChangeEvent<T>>; type KeyboardEventHandler<T = Element> = EventHandler<KeyboardEvent<T>>; type MouseEventHandler<T = Element> = EventHandler<MouseEvent<T>>; type TouchEventHandler<T = Element> = EventHandler<TouchEvent<T>>; type PointerEventHandler<T = Element> = EventHandler<PointerEvent<T>>; type UIEventHandler<T = Element> = EventHandler<UIEvent<T>>; type WheelEventHandler<T = Element> = EventHandler<WheelEvent<T>>; type AnimationEventHandler<T = Element> = EventHandler<AnimationEvent<T>>; type TransitionEventHandler<T = Element> = EventHandler<TransitionEvent<T>>; // // Props / DOM Attributes // ---------------------------------------------------------------------- /** * @deprecated. This was used to allow clients to pass `ref` and `key` * to `createElement`, which is no longer necessary due to intersection * types. If you need to declare a props object before passing it to * `createElement` or a factory, use `ClassAttributes<T>`: * * ```ts * var b: Button | null; * var props: ButtonProps & ClassAttributes<Button> = { * ref: b => button = b, // ok! * label: "I'm a Button" * }; * ``` */ interface Props<T> { children?: ReactNode; key?: Key; ref?: LegacyRef<T>; } interface HTMLProps<T> extends AllHTMLAttributes<T>, ClassAttributes<T> {} type DetailedHTMLProps<E extends HTMLAttributes<T>, T> = ClassAttributes<T> & E; interface SVGProps<T> extends SVGAttributes<T>, ClassAttributes<T> {} interface DOMAttributes<T> { children?: ReactNode; dangerouslySetInnerHTML?: { __html: string; }; // Clipboard Events onCopy?: ClipboardEventHandler<T>; onCopyCapture?: ClipboardEventHandler<T>; onCut?: ClipboardEventHandler<T>; onCutCapture?: ClipboardEventHandler<T>; onPaste?: ClipboardEventHandler<T>; onPasteCapture?: ClipboardEventHandler<T>; // Composition Events onCompositionEnd?: CompositionEventHandler<T>; onCompositionEndCapture?: CompositionEventHandler<T>; onCompositionStart?: CompositionEventHandler<T>; onCompositionStartCapture?: CompositionEventHandler<T>; onCompositionUpdate?: CompositionEventHandler<T>; onCompositionUpdateCapture?: CompositionEventHandler<T>; // Focus Events onFocus?: FocusEventHandler<T>; onFocusCapture?: FocusEventHandler<T>; onBlur?: FocusEventHandler<T>; onBlurCapture?: FocusEventHandler<T>; // Form Events onChange?: FormEventHandler<T>; onChangeCapture?: FormEventHandler<T>; onBeforeInput?: FormEventHandler<T>; onBeforeInputCapture?: FormEventHandler<T>; onInput?: FormEventHandler<T>; onInputCapture?: FormEventHandler<T>; onReset?: FormEventHandler<T>; onResetCapture?: FormEventHandler<T>; onSubmit?: FormEventHandler<T>; onSubmitCapture?: FormEventHandler<T>; onInvalid?: FormEventHandler<T>; onInvalidCapture?: FormEventHandler<T>; // Image Events onLoad?: ReactEventHandler<T>; onLoadCapture?: ReactEventHandler<T>; onError?: ReactEventHandler<T>; // also a Media Event onErrorCapture?: ReactEventHandler<T>; // also a Media Event // Keyboard Events onKeyDown?: KeyboardEventHandler<T>; onKeyDownCapture?: KeyboardEventHandler<T>; onKeyPress?: KeyboardEventHandler<T>; onKeyPressCapture?: KeyboardEventHandler<T>; onKeyUp?: KeyboardEventHandler<T>; onKeyUpCapture?: KeyboardEventHandler<T>; // Media Events onAbort?: ReactEventHandler<T>; onAbortCapture?: ReactEventHandler<T>; onCanPlay?: ReactEventHandler<T>; onCanPlayCapture?: ReactEventHandler<T>; onCanPlayThrough?: ReactEventHandler<T>; onCanPlayThroughCapture?: ReactEventHandler<T>; onDurationChange?: ReactEventHandler<T>; onDurationChangeCapture?: ReactEventHandler<T>; onEmptied?: ReactEventHandler<T>; onEmptiedCapture?: ReactEventHandler<T>; onEncrypted?: ReactEventHandler<T>; onEncryptedCapture?: ReactEventHandler<T>; onEnded?: ReactEventHandler<T>; onEndedCapture?: ReactEventHandler<T>; onLoadedData?: ReactEventHandler<T>; onLoadedDataCapture?: ReactEventHandler<T>; onLoadedMetadata?: ReactEventHandler<T>; onLoadedMetadataCapture?: ReactEventHandler<T>; onLoadStart?: ReactEventHandler<T>; onLoadStartCapture?: ReactEventHandler<T>; onPause?: ReactEventHandler<T>; onPauseCapture?: ReactEventHandler<T>; onPlay?: ReactEventHandler<T>; onPlayCapture?: ReactEventHandler<T>; onPlaying?: ReactEventHandler<T>; onPlayingCapture?: ReactEventHandler<T>; onProgress?: ReactEventHandler<T>; onProgressCapture?: ReactEventHandler<T>; onRateChange?: ReactEventHandler<T>; onRateChangeCapture?: ReactEventHandler<T>; onSeeked?: ReactEventHandler<T>; onSeekedCapture?: ReactEventHandler<T>; onSeeking?: ReactEventHandler<T>; onSeekingCapture?: ReactEventHandler<T>; onStalled?: ReactEventHandler<T>; onStalledCapture?: ReactEventHandler<T>; onSuspend?: ReactEventHandler<T>; onSuspendCapture?: ReactEventHandler<T>; onTimeUpdate?: ReactEventHandler<T>; onTimeUpdateCapture?: ReactEventHandler<T>; onVolumeChange?: ReactEventHandler<T>; onVolumeChangeCapture?: ReactEventHandler<T>; onWaiting?: ReactEventHandler<T>; onWaitingCapture?: ReactEventHandler<T>; // MouseEvents onAuxClick?: MouseEventHandler<T>; onAuxClickCapture?: MouseEventHandler<T>; onClick?: MouseEventHandler<T>; onClickCapture?: MouseEventHandler<T>; onContextMenu?: MouseEventHandler<T>; onContextMenuCapture?: MouseEventHandler<T>; onDoubleClick?: MouseEventHandler<T>; onDoubleClickCapture?: MouseEventHandler<T>; onDrag?: DragEventHandler<T>; onDragCapture?: DragEventHandler<T>; onDragEnd?: DragEventHandler<T>; onDragEndCapture?: DragEventHandler<T>; onDragEnter?: DragEventHandler<T>; onDragEnterCapture?: DragEventHandler<T>; onDragExit?: DragEventHandler<T>; onDragExitCapture?: DragEventHandler<T>; onDragLeave?: DragEventHandler<T>; onDragLeaveCapture?: DragEventHandler<T>; onDragOver?: DragEventHandler<T>; onDragOverCapture?: DragEventHandler<T>; onDragStart?: DragEventHandler<T>; onDragStartCapture?: DragEventHandler<T>; onDrop?: DragEventHandler<T>; onDropCapture?: DragEventHandler<T>; onMouseDown?: MouseEventHandler<T>; onMouseDownCapture?: MouseEventHandler<T>; onMouseEnter?: MouseEventHandler<T>; onMouseLeave?: MouseEventHandler<T>; onMouseMove?: MouseEventHandler<T>; onMouseMoveCapture?: MouseEventHandler<T>; onMouseOut?: MouseEventHandler<T>; onMouseOutCapture?: MouseEventHandler<T>; onMouseOver?: MouseEventHandler<T>; onMouseOverCapture?: MouseEventHandler<T>; onMouseUp?: MouseEventHandler<T>; onMouseUpCapture?: MouseEventHandler<T>; // Selection Events onSelect?: ReactEventHandler<T>; onSelectCapture?: ReactEventHandler<T>; // Touch Events onTouchCancel?: TouchEventHandler<T>; onTouchCancelCapture?: TouchEventHandler<T>; onTouchEnd?: TouchEventHandler<T>; onTouchEndCapture?: TouchEventHandler<T>; onTouchMove?: TouchEventHandler<T>; onTouchMoveCapture?: TouchEventHandler<T>; onTouchStart?: TouchEventHandler<T>; onTouchStartCapture?: TouchEventHandler<T>; // Pointer Events onPointerDown?: PointerEventHandler<T>; onPointerDownCapture?: PointerEventHandler<T>; onPointerMove?: PointerEventHandler<T>; onPointerMoveCapture?: PointerEventHandler<T>; onPointerUp?: PointerEventHandler<T>; onPointerUpCapture?: PointerEventHandler<T>; onPointerCancel?: PointerEventHandler<T>; onPointerCancelCapture?: PointerEventHandler<T>; onPointerEnter?: PointerEventHandler<T>; onPointerEnterCapture?: PointerEventHandler<T>; onPointerLeave?: PointerEventHandler<T>; onPointerLeaveCapture?: PointerEventHandler<T>; onPointerOver?: PointerEventHandler<T>; onPointerOverCapture?: PointerEventHandler<T>; onPointerOut?: PointerEventHandler<T>; onPointerOutCapture?: PointerEventHandler<T>; onGotPointerCapture?: PointerEventHandler<T>; onGotPointerCaptureCapture?: PointerEventHandler<T>; onLostPointerCapture?: PointerEventHandler<T>; onLostPointerCaptureCapture?: PointerEventHandler<T>; // UI Events onScroll?: UIEventHandler<T>; onScrollCapture?: UIEventHandler<T>; // Wheel Events onWheel?: WheelEventHandler<T>; onWheelCapture?: WheelEventHandler<T>; // Animation Events onAnimationStart?: AnimationEventHandler<T>; onAnimationStartCapture?: AnimationEventHandler<T>; onAnimationEnd?: AnimationEventHandler<T>; onAnimationEndCapture?: AnimationEventHandler<T>; onAnimationIteration?: AnimationEventHandler<T>; onAnimationIterationCapture?: AnimationEventHandler<T>; // Transition Events onTransitionEnd?: TransitionEventHandler<T>; onTransitionEndCapture?: TransitionEventHandler<T>; } export interface CSSProperties extends CSS.Properties<string | number> { /** * The index signature was removed to enable closed typing for style * using CSSType. You're able to use type assertion or module augmentation * to add properties or an index signature of your own. * * For examples and more information, visit: * https://github.com/frenic/csstype#what-should-i-do-when-i-get-type-errors */ } // All the WAI-ARIA 1.1 attributes from https://www.w3.org/TR/wai-aria-1.1/ interface AriaAttributes { /** Identifies the currently active element when DOM focus is on a composite widget, textbox, group, or application. */ "aria-activedescendant"?: string; /** Indicates whether assistive technologies will present all, or only parts of, the changed region based on the change notifications defined by the aria-relevant attribute. */ "aria-atomic"?: boolean | "false" | "true"; /** * Indicates whether inputting text could trigger display of one or more predictions of the user's intended value for an input and specifies how predictions would be * presented if they are made. */ "aria-autocomplete"?: "none" | "inline" | "list" | "both"; /** 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. */ "aria-busy"?: boolean | "false" | "true"; /** * Indicates the current "checked" state of checkboxes, radio buttons, and other widgets. * @see aria-pressed @see aria-selected. */ "aria-checked"?: boolean | "false" | "mixed" | "true"; /** * Defines the total number of columns in a table, grid, or treegrid. * @see aria-colindex. */ "aria-colcount"?: number; /** * Defines an element's column index or position with respect to the total number of columns within a table, grid, or treegrid. * @see aria-colcount @see aria-colspan. */ "aria-colindex"?: number; /** * Defines the number of columns spanned by a cell or gridcell within a table, grid, or treegrid. * @see aria-colindex @see aria-rowspan. */ "aria-colspan"?: number; /** * Identifies the element (or elements) whose contents or presence are controlled by the current element. * @see aria-owns. */ "aria-controls"?: string; /** Indicates the element that represents the current item within a container or set of related elements. */ "aria-current"?: | boolean | "false" | "true" | "page" | "step" | "location" | "date" | "time"; /** * Identifies the element (or elements) that describes the object. * @see aria-labelledby */ "aria-describedby"?: string; /** * Identifies the element that provides a detailed, extended description for the object. * @see aria-describedby. */ "aria-details"?: string; /** * Indicates that the element is perceivable but disabled, so it is not editable or otherwise operable. * @see aria-hidden @see aria-readonly. */ "aria-disabled"?: boolean | "false" | "true"; /** * Indicates what functions can be performed when a dragged object is released on the drop target. * @deprecated in ARIA 1.1 */ "aria-dropeffect"?: "none" | "copy" | "execute" | "link" | "move" | "popup"; /** * Identifies the element that provides an error message for the object. * @see aria-invalid @see aria-describedby. */ "aria-errormessage"?: string; /** Indicates whether the element, or another grouping element it controls, is currently expanded or collapsed. */ "aria-expanded"?: boolean | "false" | "true"; /** * Identifies the next element (or elements) in an alternate reading order of content which, at the user's discretion, * allows assistive technology to override the general default of reading in document source order. */ "aria-flowto"?: string; /** * Indicates an element's "grabbed" state in a drag-and-drop operation. * @deprecated in ARIA 1.1 */ "aria-grabbed"?: boolean | "false" | "true"; /** Indicates the availability and type of interactive popup element, such as menu or dialog, that can be triggered by an element. */ "aria-haspopup"?: | boolean | "false" | "true" | "menu" | "listbox" | "tree" | "grid" | "dialog"; /** * Indicates whether the element is exposed to an accessibility API. * @see aria-disabled. */ "aria-hidden"?: boolean | "false" | "true"; /** * Indicates the entered value does not conform to the format expected by the application. * @see aria-errormessage. */ "aria-invalid"?: boolean | "false" | "true" | "grammar" | "spelling"; /** Indicates keyboard shortcuts that an author has implemented to activate or give focus to an element. */ "aria-keyshortcuts"?: string; /** * Defines a string value that labels the current element. * @see aria-labelledby. */ "aria-label"?: string; /** * Identifies the element (or elements) that labels the current element. * @see aria-describedby. */ "aria-labelledby"?: string; /** Defines the hierarchical level of an element within a structure. */ "aria-level"?: number; /** Indicates that an element will be updated, and describes the types of updates the user agents, assistive technologies, and user can expect from the live region. */ "aria-live"?: "off" | "assertive" | "polite"; /** Indicates whether an element is modal when displayed. */ "aria-modal"?: boolean | "false" | "true"; /** Indicates whether a text box accepts multiple lines of input or only a single line. */ "aria-multiline"?: boolean | "false" | "true"; /** Indicates that the user may select more than one item from the current selectable descendants. */ "aria-multiselectable"?: boolean | "false" | "true"; /** Indicates whether the element's orientation is horizontal, vertical, or unknown/ambiguous. */ "aria-orientation"?: "horizontal" | "vertical"; /** * 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 aria-controls. */ "aria-owns"?: 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. */ "aria-placeholder"?: string; /** * 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 aria-setsize. */ "aria-posinset"?: number; /** * Indicates the current "pressed" state of toggle buttons. * @see aria-checked @see aria-selected. */ "aria-pressed"?: boolean | "false" | "mixed" | "true"; /** * Indicates that the element is not editable, but is otherwise operable. * @see aria-disabled. */ "aria-readonly"?: boolean | "false" | "true"; /** * Indicates what notifications the user agent will trigger when the accessibility tree within a live region is modified. * @see aria-atomic. */ "aria-relevant"?: | "additions" | "additions text" | "all" | "removals" | "text"; /** Indicates that user input is required on the element before a form may be submitted. */ "aria-required"?: boolean | "false" | "true"; /** Defines a human-readable, author-localized description for the role of an element. */ "aria-roledescription"?: string; /** * Defines the total number of rows in a table, grid, or treegrid. * @see aria-rowindex. */ "aria-rowcount"?: number; /** * Defines an element's row index or position with respect to the total number of rows within a table, grid, or treegrid. * @see aria-rowcount @see aria-rowspan. */ "aria-rowindex"?: number; /** * Defines the number of rows spanned by a cell or gridcell within a table, grid, or treegrid. * @see aria-rowindex @see aria-colspan. */ "aria-rowspan"?: number; /** * Indicates the current "selected" state of various widgets. * @see aria-checked @see aria-pressed. */ "aria-selected"?: boolean | "false" | "true"; /** * 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 aria-posinset. */ "aria-setsize"?: number; /** Indicates if items in a table or grid are sorted in ascending or descending order. */ "aria-sort"?: "none" | "ascending" | "descending" | "other"; /** Defines the maximum allowed value for a range widget. */ "aria-valuemax"?: number; /** Defines the minimum allowed value for a range widget. */ "aria-valuemin"?: number; /** * Defines the current value for a range widget. * @see aria-valuetext. */ "aria-valuenow"?: number; /** Defines the human readable text alternative of aria-valuenow for a range widget. */ "aria-valuetext"?: string; } interface HTMLAttributes<T> extends AriaAttributes, DOMAttributes<T> { // React-specific Attributes defaultChecked?: boolean; defaultValue?: string | number | string[]; suppressContentEditableWarning?: boolean; suppressHydrationWarning?: boolean; // Standard HTML Attributes accessKey?: string; className?: string; contentEditable?: Booleanish | "inherit"; contextMenu?: string; dir?: string; draggable?: Booleanish; hidden?: boolean; id?: string; lang?: string; placeholder?: string; slot?: string; spellCheck?: Booleanish; style?: CSSProperties; tabIndex?: number; title?: string; translate?: "yes" | "no"; // Unknown radioGroup?: string; // <command>, <menuitem> // WAI-ARIA role?: string; // RDFa Attributes about?: string; datatype?: string; inlist?: any; prefix?: string; property?: string; resource?: string; typeof?: string; vocab?: string; // Non-standard Attributes autoCapitalize?: string; autoCorrect?: string; autoSave?: string; color?: string; itemProp?: string; itemScope?: boolean; itemType?: string; itemID?: string; itemRef?: string; results?: number; security?: string; unselectable?: "on" | "off"; // Living Standard /** * Hints at the type of data that might be entered by the user while editing the element or its contents * @see https://html.spec.whatwg.org/multipage/interaction.html#input-modalities:-the-inputmode-attribute */ inputMode?: | "none" | "text" | "tel" | "url" | "email" | "numeric" | "decimal" | "search"; /** * Specify that a standard HTML element should behave like a defined custom built-in element * @see https://html.spec.whatwg.org/multipage/custom-elements.html#attr-is */ is?: string; } interface AllHTMLAttributes<T> extends HTMLAttributes<T> { // Standard HTML Attributes accept?: string; acceptCharset?: string; action?: string; allowFullScreen?: boolean; allowTransparency?: boolean; alt?: string; as?: string; async?: boolean; autoComplete?: string; autoFocus?: boolean; autoPlay?: boolean; capture?: boolean | string; cellPadding?: number | string; cellSpacing?: number | string; charSet?: string; challenge?: string; checked?: boolean; cite?: string; classID?: string; cols?: number; colSpan?: number; content?: string; controls?: boolean; coords?: string; crossOrigin?: string; data?: string; dateTime?: string; default?: boolean; defer?: boolean; disabled?: boolean; download?: any; encType?: string; form?: string; formAction?: string; formEncType?: string; formMethod?: string; formNoValidate?: boolean; formTarget?: string; frameBorder?: number | string; headers?: string; height?: number | string; high?: number; href?: string; hrefLang?: string; htmlFor?: string; httpEquiv?: string; integrity?: string; keyParams?: string; keyType?: string; kind?: string; label?: string; list?: string; loop?: boolean; low?: number; manifest?: string; marginHeight?: number; marginWidth?: number; max?: number | string; maxLength?: number; media?: string; mediaGroup?: string; method?: string; min?: number | string; minLength?: number; multiple?: boolean; muted?: boolean; name?: string; nonce?: string; noValidate?: boolean; open?: boolean; optimum?: number; pattern?: string; placeholder?: string; playsInline?: boolean; poster?: string; preload?: string; readOnly?: boolean; rel?: string; required?: boolean; reversed?: boolean; rows?: number; rowSpan?: number; sandbox?: string; scope?: string; scoped?: boolean; scrolling?: string; seamless?: boolean; selected?: boolean; shape?: string; size?: number; sizes?: string; span?: number; src?: string; srcDoc?: string; srcLang?: string; srcSet?: string; start?: number; step?: number | string; summary?: string; target?: string; type?: string; useMap?: string; value?: string | string[] | number; width?: number | string; wmode?: string; wrap?: string; } interface AnchorHTMLAttributes<T> extends HTMLAttributes<T> { download?: any; href?: string; hrefLang?: string; media?: string; ping?: string; rel?: string; target?: string; type?: string; referrerPolicy?: string; } // tslint:disable-next-line:no-empty-interface interface AudioHTMLAttributes<T> extends MediaHTMLAttributes<T> {} interface AreaHTMLAttributes<T> extends HTMLAttributes<T> { alt?: string; coords?: string; download?: any; href?: string; hrefLang?: string; media?: string; rel?: string; shape?: string; target?: string; } interface BaseHTMLAttributes<T> extends HTMLAttributes<T> { href?: string; target?: string; } interface BlockquoteHTMLAttributes<T> extends HTMLAttributes<T> { cite?: string; } interface ButtonHTMLAttributes<T> extends HTMLAttributes<T> { autoFocus?: boolean; disabled?: boolean; form?: string; formAction?: string; formEncType?: string; formMethod?: string; formNoValidate?: boolean; formTarget?: string; name?: string; type?: "submit" | "reset" | "button"; value?: string | string[] | number; } interface CanvasHTMLAttributes<T> extends HTMLAttributes<T> { height?: number | string; width?: number | string; } interface ColHTMLAttributes<T> extends HTMLAttributes<T> { span?: number; width?: number | string; } interface ColgroupHTMLAttributes<T> extends HTMLAttributes<T> { span?: number; } interface DataHTMLAttributes<T> extends HTMLAttributes<T> { value?: string | string[] | number; } interface DetailsHTMLAttributes<T> extends HTMLAttributes<T> { open?: boolean; } interface DelHTMLAttributes<T> extends HTMLAttributes<T> { cite?: string; dateTime?: string; } interface DialogHTMLAttributes<T> extends HTMLAttributes<T> { open?: boolean; } interface EmbedHTMLAttributes<T> extends HTMLAttributes<T> { height?: number | string; src?: string; type?: string; width?: number | string; } interface FieldsetHTMLAttributes<T> extends HTMLAttributes<T> { disabled?: boolean; form?: string; name?: string; } interface FormHTMLAttributes<T> extends HTMLAttributes<T> { acceptCharset?: string; action?: string; autoComplete?: string; encType?: string; method?: string; name?: string; noValidate?: boolean; target?: string; } interface HtmlHTMLAttributes<T> extends HTMLAttributes<T> { manifest?: string; } interface IframeHTMLAttributes<T> extends HTMLAttributes<T> { allow?: string; allowFullScreen?: boolean; allowTransparency?: boolean; frameBorder?: number | string; height?: number | string; marginHeight?: number; marginWidth?: number; name?: string; referrerPolicy?: string; sandbox?: string; scrolling?: string; seamless?: boolean; src?: string; srcDoc?: string; width?: number | string; } interface ImgHTMLAttributes<T> extends HTMLAttributes<T> { alt?: string; crossOrigin?: "anonymous" | "use-credentials" | ""; decoding?: "async" | "auto" | "sync"; height?: number | string; sizes?: string; src?: string; srcSet?: string; useMap?: string; width?: number | string; } interface InsHTMLAttributes<T> extends HTMLAttributes<T> { cite?: string; dateTime?: string; } interface InputHTMLAttributes<T> extends HTMLAttributes<T> { accept?: string; alt?: string; autoComplete?: string; autoFocus?: boolean; capture?: boolean | string; // https://www.w3.org/TR/html-media-capture/#the-capture-attribute checked?: boolean; crossOrigin?: string; disabled?: boolean; form?: string; formAction?: string; formEncType?: string; formMethod?: string; formNoValidate?: boolean; formTarget?: string; height?: number | string; list?: string; max?: number | string; maxLength?: number; min?: number | string; minLength?: number; multiple?: boolean; name?: string; pattern?: string; placeholder?: string; readOnly?: boolean; required?: boolean; size?: number; src?: string; step?: number | string; type?: string; value?: string | string[] | number; width?: number | string; onChange?: ChangeEventHandler<T>; } interface KeygenHTMLAttributes<T> extends HTMLAttributes<T> { autoFocus?: boolean; challenge?: string; disabled?: boolean; form?: string; keyType?: string; keyParams?: string; name?: string; } interface LabelHTMLAttributes<T> extends HTMLAttributes<T> { form?: string; htmlFor?: string; } interface LiHTMLAttributes<T> extends HTMLAttributes<T> { value?: string | string[] | number; } interface LinkHTMLAttributes<T> extends HTMLAttributes<T> { as?: string; crossOrigin?: string; href?: string; hrefLang?: string; integrity?: string; media?: string; rel?: string; sizes?: string; type?: string; } interface MapHTMLAttributes<T> extends HTMLAttributes<T> { name?: string; } interface MenuHTMLAttributes<T> extends HTMLAttributes<T> { type?: string; } interface MediaHTMLAttributes<T> extends HTMLAttributes<T> { autoPlay?: boolean; controls?: boolean; controlsList?: string; crossOrigin?: string; loop?: boolean; mediaGroup?: string; muted?: boolean; playsinline?: boolean; preload?: string; src?: string; } interface MetaHTMLAttributes<T> extends HTMLAttributes<T> { charSet?: string; content?: string; httpEquiv?: string; name?: string; } interface MeterHTMLAttributes<T> extends HTMLAttributes<T> { form?: string; high?: number; low?: number; max?: number | string; min?: number | string; optimum?: number; value?: string | string[] | number; } interface QuoteHTMLAttributes<T> extends HTMLAttributes<T> { cite?: string; } interface ObjectHTMLAttributes<T> extends HTMLAttributes<T> { classID?: string; data?: string; form?: string; height?: number | string; name?: string; type?: string; useMap?: string; width?: number | string; wmode?: string; } interface OlHTMLAttributes<T> extends HTMLAttributes<T> { reversed?: boolean; start?: number; type?: "1" | "a" | "A" | "i" | "I"; } interface OptgroupHTMLAttributes<T> extends HTMLAttributes<T> { disabled?: boolean; label?: string; } interface OptionHTMLAttributes<T> extends HTMLAttributes<T> { disabled?: boolean; label?: string; selected?: boolean; value?: string | string[] | number; } interface OutputHTMLAttributes<T> extends HTMLAttributes<T> { form?: string; htmlFor?: string; name?: string; } interface ParamHTMLAttributes<T> extends HTMLAttributes<T> { name?: string; value?: string | string[] | number; } interface ProgressHTMLAttributes<T> extends HTMLAttributes<T> { max?: number | string; value?: string | string[] | number; } interface ScriptHTMLAttributes<T> extends HTMLAttributes<T> { async?: boolean; charSet?: string; crossOrigin?: string; defer?: boolean; integrity?: string; noModule?: boolean; nonce?: string; src?: string; type?: string; } interface SelectHTMLAttributes<T> extends HTMLAttributes<T> { autoComplete?: string; autoFocus?: boolean; disabled?: boolean; form?: string; multiple?: boolean; name?: string; required?: boolean; size?: number; value?: string | string[] | number; onChange?: ChangeEventHandler<T>; } interface SourceHTMLAttributes<T> extends HTMLAttributes<T> { media?: string; sizes?: string; src?: string; srcSet?: string; type?: string; } interface StyleHTMLAttributes<T> extends HTMLAttributes<T> { media?: string; nonce?: string; scoped?: boolean; type?: string; } interface TableHTMLAttributes<T> extends HTMLAttributes<T> { cellPadding?: number | string; cellSpacing?: number | string; summary?: string; } interface TextareaHTMLAttributes<T> extends HTMLAttributes<T> { autoComplete?: string; autoFocus?: boolean; cols?: number; dirName?: string; disabled?: boolean; form?: string; maxLength?: number; minLength?: number; name?: string; placeholder?: string; readOnly?: boolean; required?: boolean; rows?: number; value?: string | string[] | number; wrap?: string; onChange?: ChangeEventHandler<T>; } interface TdHTMLAttributes<T> extends HTMLAttributes<T> { align?: "left" | "center" | "right" | "justify" | "char"; colSpan?: number; headers?: string; rowSpan?: number; scope?: string; abbr?: string; valign?: "top" | "middle" | "bottom" | "baseline"; } interface ThHTMLAttributes<T> extends HTMLAttributes<T> { align?: "left" | "center" | "right" | "justify" | "char"; colSpan?: number; headers?: string; rowSpan?: number; scope?: string; abbr?: string; } interface TimeHTMLAttributes<T> extends HTMLAttributes<T> { dateTime?: string; } interface TrackHTMLAttributes<T> extends HTMLAttributes<T> { default?: boolean; kind?: string; label?: string; src?: string; srcLang?: string; } interface VideoHTMLAttributes<T> extends MediaHTMLAttributes<T> { height?: number | string; playsInline?: boolean; poster?: string; width?: number | string; disablePictureInPicture?: boolean; } // this list is "complete" in that it contains every SVG attribute // that React supports, but the types can be improved. // Full list here: https://facebook.github.io/react/docs/dom-elements.html // // The three broad type categories are (in order of restrictiveness): // - "number | string" // - "string" // - union of string literals interface SVGAttributes<T> extends AriaAttributes, DOMAttributes<T> { // Attributes which also defined in HTMLAttributes // See comment in SVGDOMPropertyConfig.js className?: string; color?: string; height?: number | string; id?: string; lang?: string; max?: number | string; media?: string; method?: string; min?: number | string; name?: string; style?: CSSProperties; target?: string; type?: string; width?: number | string; // Other HTML properties supported by SVG elements in browsers role?: string; tabIndex?: number; crossOrigin?: "anonymous" | "use-credentials" | ""; // SVG Specific attributes accentHeight?: number | string; accumulate?: "none" | "sum"; additive?: "replace" | "sum"; alignmentBaseline?: | "auto" | "baseline" | "before-edge" | "text-before-edge" | "middle" | "central" | "after-edge" | "text-after-edge" | "ideographic" | "alphabetic" | "hanging" | "mathematical" | "inherit"; allowReorder?: "no" | "yes"; alphabetic?: number | string; amplitude?: number | string; arabicForm?: "initial" | "medial" | "terminal" | "isolated"; ascent?: number | string; attributeName?: string; attributeType?: string; autoReverse?: Booleanish; azimuth?: number | string; baseFrequency?: number | string; baselineShift?: number | string; baseProfile?: number | string; bbox?: number | string; begin?: number | string; bias?: number | string; by?: number | string; calcMode?: number | string; capHeight?: number | string; clip?: number | string; clipPath?: string; clipPathUnits?: number | string; clipRule?: number | string; colorInterpolation?: number | string; colorInterpolationFilters?: "auto" | "sRGB" | "linearRGB" | "inherit"; colorProfile?: number | string; colorRendering?: number | string; contentScriptType?: number | string; contentStyleType?: number | string; cursor?: number | string; cx?: number | string; cy?: number | string; d?: string; decelerate?: number | string; descent?: number | string; diffuseConstant?: number | string; direction?: number | string; display?: number | string; divisor?: number | string; dominantBaseline?: number | string; dur?: number | string; dx?: number | string; dy?: number | string; edgeMode?: number | string; elevation?: number | string; enableBackground?: number | string; end?: number | string; exponent?: number | string; externalResourcesRequired?: Booleanish; fill?: string; fillOpacity?: number | string; fillRule?: "nonzero" | "evenodd" | "inherit"; filter?: string; filterRes?: number | string; filterUnits?: number | string; floodColor?: number | string; floodOpacity?: number | string; focusable?: Booleanish | "auto"; fontFamily?: string; fontSize?: number | string; fontSizeAdjust?: number | string; fontStretch?: number | string; fontStyle?: number | string; fontVariant?: number | string; fontWeight?: number | string; format?: number | string; from?: number | string; fx?: number | string; fy?: number | string; g1?: number | string; g2?: number | string; glyphName?: number | string; glyphOrientationHorizontal?: number | string; glyphOrientationVertical?: number | string; glyphRef?: number | string; gradientTransform?: string; gradientUnits?: string; hanging?: number | string; horizAdvX?: number | string; horizOriginX?: number | string; href?: string; ideographic?: number | string; imageRendering?: number | string; in2?: number | string; in?: string; intercept?: number | string; k1?: number | string; k2?: number | string; k3?: number | string; k4?: number | string; k?: number | string; kernelMatrix?: number | string; kernelUnitLength?: number | string; kerning?: number | string; keyPoints?: number | string; keySplines?: number | string; keyTimes?: number | string; lengthAdjust?: number | string; letterSpacing?: number | string; lightingColor?: number | string; limitingConeAngle?: number | string; local?: number | string; markerEnd?: string; markerHeight?: number | string; markerMid?: string; markerStart?: string; markerUnits?: number | string; markerWidth?: number | string; mask?: string; maskContentUnits?: number | string; maskUnits?: number | string; mathematical?: number | string; mode?: number | string; numOctaves?: number | string; offset?: number | string; opacity?: number | string; operator?: number | string; order?: number | string; orient?: number | string; orientation?: number | string; origin?: number | string; overflow?: number | string; overlinePosition?: number | string; overlineThickness?: number | string; paintOrder?: number | string; panose1?: number | string; pathLength?: number | string; patternContentUnits?: string; patternTransform?: number | string; patternUnits?: string; pointerEvents?: number | string; points?: string; pointsAtX?: number | string; pointsAtY?: number | string; pointsAtZ?: number | string; preserveAlpha?: Booleanish; preserveAspectRatio?: string; primitiveUnits?: number | string; r?: number | string; radius?: number | string; refX?: number | string; refY?: number | string; renderingIntent?: number | string; repeatCount?: number | string; repeatDur?: number | string; requiredExtensions?: number | string; requiredFeatures?: number | string; restart?: number | string; result?: string; rotate?: number | string; rx?: number | string; ry?: number | string; scale?: number | string; seed?: number | string; shapeRendering?: number | string; slope?: number | string; spacing?: number | string; specularConstant?: number | string; specularExponent?: number | string; speed?: number | string; spreadMethod?: string; startOffset?: number | string; stdDeviation?: number | string; stemh?: number | string; stemv?: number | string; stitchTiles?: number | string; stopColor?: string; stopOpacity?: number | string; strikethroughPosition?: number | string; strikethroughThickness?: number | string; string?: number | string; stroke?: string; strokeDasharray?: string | number; strokeDashoffset?: string | number; strokeLinecap?: "butt" | "round" | "square" | "inherit"; strokeLinejoin?: "miter" | "round" | "bevel" | "inherit"; strokeMiterlimit?: number | string; strokeOpacity?: number | string; strokeWidth?: number | string; surfaceScale?: number | string; systemLanguage?: number | string; tableValues?: number | string; targetX?: number | string; targetY?: number | string; textAnchor?: string; textDecoration?: number | string; textLength?: number | string; textRendering?: number | string; to?: number | string; transform?: string; u1?: number | string; u2?: number | string; underlinePosition?: number | string; underlineThickness?: number | string; unicode?: number | string; unicodeBidi?: number | string; unicodeRange?: number | string; unitsPerEm?: number | string; vAlphabetic?: number | string; values?: string; vectorEffect?: number | string; version?: string; vertAdvY?: number | string; vertOriginX?: number | string; vertOriginY?: number | string; vHanging?: number | string; vIdeographic?: number | string; viewBox?: string; viewTarget?: number | string; visibility?: number | string; vMathematical?: number | string; widths?: number | string; wordSpacing?: number | string; writingMode?: number | string; x1?: number | string; x2?: number | string; x?: number | string; xChannelSelector?: string; xHeight?: number | string; xlinkActuate?: string; xlinkArcrole?: string; xlinkHref?: string; xlinkRole?: string; xlinkShow?: string; xlinkTitle?: string; xlinkType?: string; xmlBase?: string; xmlLang?: string; xmlns?: string; xmlnsXlink?: string; xmlSpace?: string; y1?: number | string; y2?: number | string; y?: number | string; yChannelSelector?: string; z?: number | string; zoomAndPan?: string; } interface WebViewHTMLAttributes<T> extends HTMLAttributes<T> { allowFullScreen?: boolean; allowpopups?: boolean; autoFocus?: boolean; autosize?: boolean; blinkfeatures?: string; disableblinkfeatures?: string; disableguestresize?: boolean; disablewebsecurity?: boolean; guestinstance?: string; httpreferrer?: string; nodeintegration?: boolean; partition?: string; plugins?: boolean; preload?: string; src?: string; useragent?: string; webpreferences?: string; } // // React.DOM // ---------------------------------------------------------------------- interface ReactHTML { a: DetailedHTMLFactory< AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement >; abbr: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>; address: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>; area: DetailedHTMLFactory< AreaHTMLAttributes<HTMLAreaElement>, HTMLAreaElement >; article: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>; aside: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>; audio: DetailedHTMLFactory< AudioHTMLAttributes<HTMLAudioElement>, HTMLAudioElement >; b: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>; base: DetailedHTMLFactory< BaseHTMLAttributes<HTMLBaseElement>, HTMLBaseElement >; bdi: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>; bdo: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>; big: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>; blockquote: DetailedHTMLFactory< BlockquoteHTMLAttributes<HTMLElement>, HTMLElement >; body: DetailedHTMLFactory<HTMLAttributes<HTMLBodyElement>, HTMLBodyElement>; br: DetailedHTMLFactory<HTMLAttributes<HTMLBRElement>, HTMLBRElement>; button: DetailedHTMLFactory< ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement >; canvas: DetailedHTMLFactory< CanvasHTMLAttributes<HTMLCanvasElement>, HTMLCanvasElement >; caption: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>; cite: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>; code: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>; col: DetailedHTMLFactory< ColHTMLAttributes<HTMLTableColElement>, HTMLTableColElement >; colgroup: DetailedHTMLFactory< ColgroupHTMLAttributes<HTMLTableColElement>, HTMLTableColElement >; data: DetailedHTMLFactory< DataHTMLAttributes<HTMLDataElement>, HTMLDataElement >; datalist: DetailedHTMLFactory< HTMLAttributes<HTMLDataListElement>, HTMLDataListElement >; dd: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>; del: DetailedHTMLFactory<DelHTMLAttributes<HTMLElement>, HTMLElement>; details: DetailedHTMLFactory< DetailsHTMLAttributes<HTMLElement>, HTMLElement >; dfn: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>; dialog: DetailedHTMLFactory< DialogHTMLAttributes<HTMLDialogElement>, HTMLDialogElement >; div: DetailedHTMLFactory<HTMLAttributes<HTMLDivElement>, HTMLDivElement>; dl: DetailedHTMLFactory<HTMLAttributes<HTMLDListElement>, HTMLDListElement>; dt: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>; em: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>; embed: DetailedHTMLFactory< EmbedHTMLAttributes<HTMLEmbedElement>, HTMLEmbedElement >; fieldset: DetailedHTMLFactory< FieldsetHTMLAttributes<HTMLFieldSetElement>, HTMLFieldSetElement >; figcaption: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>; figure: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>; footer: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>; form: DetailedHTMLFactory< FormHTMLAttributes<HTMLFormElement>, HTMLFormElement >; h1: DetailedHTMLFactory< HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement >; h2: DetailedHTMLFactory< HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement >; h3: DetailedHTMLFactory< HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement >; h4: DetailedHTMLFactory< HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement >; h5: DetailedHTMLFactory< HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement >; h6: DetailedHTMLFactory< HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement >; head: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLHeadElement>; header: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>; hgroup: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>; hr: DetailedHTMLFactory<HTMLAttributes<HTMLHRElement>, HTMLHRElement>; html: DetailedHTMLFactory< HtmlHTMLAttributes<HTMLHtmlElement>, HTMLHtmlElement >; i: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>; iframe: DetailedHTMLFactory< IframeHTMLAttributes<HTMLIFrameElement>, HTMLIFrameElement >; img: DetailedHTMLFactory< ImgHTMLAttributes<HTMLImageElement>, HTMLImageElement >; input: DetailedHTMLFactory< InputHTMLAttributes<HTMLInputElement>, HTMLInputElement >; ins: DetailedHTMLFactory<InsHTMLAttributes<HTMLModElement>, HTMLModElement>; kbd: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>; keygen: DetailedHTMLFactory<KeygenHTMLAttributes<HTMLElement>, HTMLElement>; label: DetailedHTMLFactory< LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement >; legend: DetailedHTMLFactory< HTMLAttributes<HTMLLegendElement>, HTMLLegendElement >; li: DetailedHTMLFactory<LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>; link: DetailedHTMLFactory< LinkHTMLAttributes<HTMLLinkElement>, HTMLLinkElement >; main: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>; map: DetailedHTMLFactory<MapHTMLAttributes<HTMLMapElement>, HTMLMapElement>; mark: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>; menu: DetailedHTMLFactory<MenuHTMLAttributes<HTMLElement>, HTMLElement>; menuitem: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>; meta: DetailedHTMLFactory< MetaHTMLAttributes<HTMLMetaElement>, HTMLMetaElement >; meter: DetailedHTMLFactory<MeterHTMLAttributes<HTMLElement>, HTMLElement>; nav: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>; noscript: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>; object: DetailedHTMLFactory< ObjectHTMLAttributes<HTMLObjectElement>, HTMLObjectElement >; ol: DetailedHTMLFactory< OlHTMLAttributes<HTMLOListElement>, HTMLOListElement >; optgroup: DetailedHTMLFactory< OptgroupHTMLAttributes<HTMLOptGroupElement>, HTMLOptGroupElement >; option: DetailedHTMLFactory< OptionHTMLAttributes<HTMLOptionElement>, HTMLOptionElement >; output: DetailedHTMLFactory<OutputHTMLAttributes<HTMLElement>, HTMLElement>; p: DetailedHTMLFactory< HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement >; param: DetailedHTMLFactory< ParamHTMLAttributes<HTMLParamElement>, HTMLParamElement >; picture: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>; pre: DetailedHTMLFactory<HTMLAttributes<HTMLPreElement>, HTMLPreElement>; progress: DetailedHTMLFactory< ProgressHTMLAttributes<HTMLProgressElement>, HTMLProgressElement >; q: DetailedHTMLFactory< QuoteHTMLAttributes<HTMLQuoteElement>, HTMLQuoteElement >; rp: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>; rt: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>; ruby: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>; s: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>; samp: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>; script: DetailedHTMLFactory< ScriptHTMLAttributes<HTMLScriptElement>, HTMLScriptElement >; section: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>; select: DetailedHTMLFactory< SelectHTMLAttributes<HTMLSelectElement>, HTMLSelectElement >; small: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>; source: DetailedHTMLFactory< SourceHTMLAttributes<HTMLSourceElement>, HTMLSourceElement >; span: DetailedHTMLFactory<HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>; strong: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>; style: DetailedHTMLFactory< StyleHTMLAttributes<HTMLStyleElement>, HTMLStyleElement >; sub: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>; summary: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>; sup: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>; table: DetailedHTMLFactory< TableHTMLAttributes<HTMLTableElement>, HTMLTableElement >; template: DetailedHTMLFactory< HTMLAttributes<HTMLTemplateElement>, HTMLTemplateElement >; tbody: DetailedHTMLFactory< HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement >; td: DetailedHTMLFactory< TdHTMLAttributes<HTMLTableDataCellElement>, HTMLTableDataCellElement >; textarea: DetailedHTMLFactory< TextareaHTMLAttributes<HTMLTextAreaElement>, HTMLTextAreaElement >; tfoot: DetailedHTMLFactory< HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement >; th: DetailedHTMLFactory< ThHTMLAttributes<HTMLTableHeaderCellElement>, HTMLTableHeaderCellElement >; thead: DetailedHTMLFactory< HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement >; time: DetailedHTMLFactory<TimeHTMLAttributes<HTMLElement>, HTMLElement>; title: DetailedHTMLFactory< HTMLAttributes<HTMLTitleElement>, HTMLTitleElement >; tr: DetailedHTMLFactory< HTMLAttributes<HTMLTableRowElement>, HTMLTableRowElement >; track: DetailedHTMLFactory< TrackHTMLAttributes<HTMLTrackElement>, HTMLTrackElement >; u: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>; ul: DetailedHTMLFactory<HTMLAttributes<HTMLUListElement>, HTMLUListElement>; var: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>; video: DetailedHTMLFactory< VideoHTMLAttributes<HTMLVideoElement>, HTMLVideoElement >; wbr: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>; webview: DetailedHTMLFactory< WebViewHTMLAttributes<HTMLWebViewElement>, HTMLWebViewElement >; } interface ReactSVG { animate: SVGFactory; circle: SVGFactory; clipPath: SVGFactory; defs: SVGFactory; desc: SVGFactory; ellipse: SVGFactory; feBlend: SVGFactory; feColorMatrix: SVGFactory; feComponentTransfer: SVGFactory; feComposite: SVGFactory; feConvolveMatrix: SVGFactory; feDiffuseLighting: SVGFactory; feDisplacementMap: SVGFactory; feDistantLight: SVGFactory; feDropShadow: SVGFactory; feFlood: SVGFactory; feFuncA: SVGFactory; feFuncB: SVGFactory; feFuncG: SVGFactory; feFuncR: SVGFactory; feGaussianBlur: SVGFactory; feImage: SVGFactory; feMerge: SVGFactory; feMergeNode: SVGFactory; feMorphology: SVGFactory; feOffset: SVGFactory; fePointLight: SVGFactory; feSpecularLighting: SVGFactory; feSpotLight: SVGFactory; feTile: SVGFactory; feTurbulence: SVGFactory; filter: SVGFactory; foreignObject: SVGFactory; g: SVGFactory; image: SVGFactory; line: SVGFactory; linearGradient: SVGFactory; marker: SVGFactory; mask: SVGFactory; metadata: SVGFactory; path: SVGFactory; pattern: SVGFactory; polygon: SVGFactory; polyline: SVGFactory; radialGradient: SVGFactory; rect: SVGFactory; stop: SVGFactory; svg: SVGFactory; switch: SVGFactory; symbol: SVGFactory; text: SVGFactory; textPath: SVGFactory; tspan: SVGFactory; use: SVGFactory; view: SVGFactory; } interface ReactDOM extends ReactHTML, ReactSVG {} // // React.PropTypes // ---------------------------------------------------------------------- type Validator<T> = PropTypes.Validator<T>; type Requireable<T> = PropTypes.Requireable<T>;